diff --git a/test/quantize_func_test.cc b/test/quantize_func_test.cc
index f3f5c85..9a5698e 100644
--- a/test/quantize_func_test.cc
+++ b/test/quantize_func_test.cc
@@ -35,9 +35,18 @@
       tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, \
       const int16_t *scan, const int16_t *iscan
 
+#define LP_QUANTIZE_PARAM_LIST                                             \
+  const int16_t *coeff_ptr, intptr_t n_coeffs, const int16_t *round_ptr,   \
+      const int16_t *quant_ptr, int16_t *qcoeff_ptr, int16_t *dqcoeff_ptr, \
+      const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan,  \
+      const int16_t *iscan
+
+typedef void (*LPQuantizeFunc)(LP_QUANTIZE_PARAM_LIST);
 typedef void (*QuantizeFunc)(QUAN_PARAM_LIST);
 typedef void (*QuantizeFuncHbd)(QUAN_PARAM_LIST, int log_scale);
 
+#undef LP_QUANTIZE_PARAM_LIST
+
 #define HBD_QUAN_FUNC                                                      \
   fn(coeff_ptr, n_coeffs, zbin_ptr, round_ptr, quant_ptr, quant_shift_ptr, \
      qcoeff_ptr, dqcoeff_ptr, dequant_ptr, eob_ptr, scan, iscan, log_scale)
@@ -67,8 +76,10 @@
 enum QuantType { TYPE_B, TYPE_DC, TYPE_FP };
 
 using std::tuple;
-typedef tuple<QuantizeFunc, QuantizeFunc, TX_SIZE, QuantType, aom_bit_depth_t>
-    QuantizeParam;
+
+template <typename FuncType>
+using QuantizeParam =
+    tuple<FuncType, FuncType, TX_SIZE, QuantType, aom_bit_depth_t>;
 
 typedef struct {
   QUANTS quant;
@@ -77,12 +88,16 @@
 
 const int kTestNum = 1000;
 
-template <typename CoeffType>
-class QuantizeTestBase : public ::testing::TestWithParam<QuantizeParam> {
+#define GET_TEMPLATE_PARAM(k) std::get<k>(this->GetParam())
+
+template <typename CoeffType, typename FuncType>
+class QuantizeTestBase
+    : public ::testing::TestWithParam<QuantizeParam<FuncType>> {
  protected:
   QuantizeTestBase()
-      : quant_ref_(GET_PARAM(0)), quant_(GET_PARAM(1)), tx_size_(GET_PARAM(2)),
-        type_(GET_PARAM(3)), bd_(GET_PARAM(4)) {}
+      : quant_ref_(GET_TEMPLATE_PARAM(0)), quant_(GET_TEMPLATE_PARAM(1)),
+        tx_size_(GET_TEMPLATE_PARAM(2)), type_(GET_TEMPLATE_PARAM(3)),
+        bd_(GET_TEMPLATE_PARAM(4)) {}
 
   virtual ~QuantizeTestBase() {}
 
@@ -153,14 +168,6 @@
                       qcoeff, qcoeff_ref, dqcoeff, dqcoeff_ref, dequant,
                       &eob[0], &eob[1], sc->scan, sc->iscan);
 
-      quant_ref_(coeff_ptr, n_coeffs, zbin, round, quant, quant_shift,
-                 qcoeff_ref, dqcoeff_ref, dequant, &eob[0], sc->scan,
-                 sc->iscan);
-
-      API_REGISTER_STATE_CHECK(quant_(coeff_ptr, n_coeffs, zbin, round, quant,
-                                      quant_shift, qcoeff, dqcoeff, dequant,
-                                      &eob[1], sc->scan, sc->iscan));
-
       for (int j = 0; j < n_coeffs; ++j) {
         ASSERT_EQ(qcoeff_ref[j], qcoeff[j])
             << "Q mismatch on test: " << i << " at position: " << j
@@ -248,14 +255,15 @@
   ACMRandom rnd_;
   QuanTable *qtab_;
   CoeffType *coeff_;
-  QuantizeFunc quant_ref_;
-  QuantizeFunc quant_;
+  FuncType quant_ref_;
+  FuncType quant_;
   TX_SIZE tx_size_;
   QuantType type_;
   aom_bit_depth_t bd_;
 };
 
-class FullPrecisionQuantizeTest : public QuantizeTestBase<tran_low_t> {
+class FullPrecisionQuantizeTest
+    : public QuantizeTestBase<tran_low_t, QuantizeFunc> {
   void RunQuantizeFunc(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
                        const int16_t *zbin_ptr, const int16_t *round_ptr,
                        const int16_t *quant_ptr, const int16_t *quant_shift_ptr,
@@ -274,6 +282,25 @@
   }
 };
 
+class LowPrecisionQuantizeTest
+    : public QuantizeTestBase<int16_t, LPQuantizeFunc> {
+  void RunQuantizeFunc(const int16_t *coeff_ptr, intptr_t n_coeffs,
+                       const int16_t * /*zbin_ptr*/, const int16_t *round_ptr,
+                       const int16_t *quant_ptr,
+                       const int16_t * /*quant_shift_ptr*/, int16_t *qcoeff_ptr,
+                       int16_t *qcoeff_ref_ptr, int16_t *dqcoeff_ptr,
+                       int16_t *dqcoeff_ref_ptr, const int16_t *dequant_ptr,
+                       uint16_t *eob_ref_ptr, uint16_t *eob_ptr,
+                       const int16_t *scan, const int16_t *iscan) override {
+    quant_ref_(coeff_ptr, n_coeffs, round_ptr, quant_ptr, qcoeff_ref_ptr,
+               dqcoeff_ref_ptr, dequant_ptr, eob_ref_ptr, scan, iscan);
+
+    API_REGISTER_STATE_CHECK(quant_(coeff_ptr, n_coeffs, round_ptr, quant_ptr,
+                                    qcoeff_ptr, dqcoeff_ptr, dequant_ptr,
+                                    eob_ptr, scan, iscan));
+  }
+};
+
 TEST_P(FullPrecisionQuantizeTest, ZeroInput) {
   FillCoeffZero();
   QuantizeRun(false);
@@ -358,10 +385,106 @@
   }
 }
 
+// TODO(crbug.com/aomedia/2796)
+TEST_P(LowPrecisionQuantizeTest, ZeroInput) {
+  FillCoeffZero();
+  QuantizeRun(false);
+}
+
+TEST_P(LowPrecisionQuantizeTest, LargeNegativeInput) {
+  FillDcLargeNegative();
+  QuantizeRun(false, 0, 1);
+}
+
+TEST_P(LowPrecisionQuantizeTest, DcOnlyInput) {
+  FillDcOnly();
+  QuantizeRun(false, 0, 1);
+}
+
+TEST_P(LowPrecisionQuantizeTest, RandomInput) {
+  QuantizeRun(true, 0, kTestNum);
+}
+
+TEST_P(LowPrecisionQuantizeTest, MultipleQ) {
+  for (int q = 0; q < QINDEX_RANGE; ++q) {
+    QuantizeRun(true, q, kTestNum);
+  }
+}
+
+// Force the coeff to be half the value of the dequant.  This exposes a
+// mismatch found in av1_quantize_fp_sse2().
+TEST_P(LowPrecisionQuantizeTest, CoeffHalfDequant) {
+  FillCoeff(16);
+  QuantizeRun(false, 25, 1);
+}
+
+TEST_P(LowPrecisionQuantizeTest, DISABLED_Speed) {
+  int16_t *coeff_ptr = coeff_;
+  const intptr_t n_coeffs = coeff_num();
+
+  int16_t *qcoeff_ref = coeff_ptr + n_coeffs;
+  int16_t *dqcoeff_ref = qcoeff_ref + n_coeffs;
+
+  int16_t *qcoeff = dqcoeff_ref + n_coeffs;
+  int16_t *dqcoeff = qcoeff + n_coeffs;
+  uint16_t *eob = (uint16_t *)(dqcoeff + n_coeffs);
+
+  // Testing uses 2-D DCT scan order table
+  const SCAN_ORDER *const sc = get_default_scan(tx_size_, DCT_DCT);
+
+  // Testing uses luminance quantization table
+  const int q = 22;
+  const int16_t *round_fp = qtab_->quant.y_round_fp[q];
+  const int16_t *quant_fp = qtab_->quant.y_quant_fp[q];
+  const int16_t *dequant = qtab_->dequant.y_dequant_QTX[q];
+  const int kNumTests = 5000000;
+  aom_usec_timer timer, simd_timer;
+  int rows = tx_size_high[tx_size_];
+  int cols = tx_size_wide[tx_size_];
+  rows = AOMMIN(32, rows);
+  cols = AOMMIN(32, cols);
+  for (int cnt = 0; cnt <= rows; cnt++) {
+    FillCoeffRandomRows(cnt * cols);
+
+    aom_usec_timer_start(&timer);
+    for (int n = 0; n < kNumTests; ++n) {
+      quant_ref_(coeff_ptr, n_coeffs, round_fp, quant_fp, qcoeff, dqcoeff,
+                 dequant, eob, sc->scan, sc->iscan);
+    }
+    aom_usec_timer_mark(&timer);
+
+    aom_usec_timer_start(&simd_timer);
+    for (int n = 0; n < kNumTests; ++n) {
+      quant_(coeff_ptr, n_coeffs, round_fp, quant_fp, qcoeff, dqcoeff, dequant,
+             eob, sc->scan, sc->iscan);
+    }
+    aom_usec_timer_mark(&simd_timer);
+
+    const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
+    const int simd_elapsed_time =
+        static_cast<int>(aom_usec_timer_elapsed(&simd_timer));
+    printf("c_time = %d \t simd_time = %d \t Gain = %f \n", elapsed_time,
+           simd_elapsed_time, ((float)elapsed_time / simd_elapsed_time));
+  }
+}
+
 using std::make_tuple;
 
 #if HAVE_AVX2
-const QuantizeParam kQParamArrayAvx2[] = {
+
+const QuantizeParam<LPQuantizeFunc> kLPQParamArrayAvx2[] = {
+  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_avx2,
+             static_cast<TX_SIZE>(TX_16X16), TYPE_FP, AOM_BITS_8),
+  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_avx2,
+             static_cast<TX_SIZE>(TX_32X32), TYPE_FP, AOM_BITS_8),
+  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_avx2,
+             static_cast<TX_SIZE>(TX_64X64), TYPE_FP, AOM_BITS_8)
+};
+
+INSTANTIATE_TEST_SUITE_P(AVX2, LowPrecisionQuantizeTest,
+                         ::testing::ValuesIn(kLPQParamArrayAvx2));
+
+const QuantizeParam<QuantizeFunc> kQParamArrayAvx2[] = {
   make_tuple(&av1_quantize_fp_c, &av1_quantize_fp_avx2,
              static_cast<TX_SIZE>(TX_16X16), TYPE_FP, AOM_BITS_8),
   make_tuple(&av1_quantize_fp_c, &av1_quantize_fp_avx2,
@@ -446,7 +569,20 @@
 #endif  // HAVE_AVX2
 
 #if HAVE_SSE2
-const QuantizeParam kQParamArraySSE2[] = {
+
+const QuantizeParam<LPQuantizeFunc> kLPQParamArraySSE2[] = {
+  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_sse2,
+             static_cast<TX_SIZE>(TX_16X16), TYPE_FP, AOM_BITS_8),
+  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_sse2,
+             static_cast<TX_SIZE>(TX_8X8), TYPE_FP, AOM_BITS_8),
+  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_sse2,
+             static_cast<TX_SIZE>(TX_4X4), TYPE_FP, AOM_BITS_8)
+};
+
+INSTANTIATE_TEST_SUITE_P(SSE2, LowPrecisionQuantizeTest,
+                         ::testing::ValuesIn(kLPQParamArraySSE2));
+
+const QuantizeParam<QuantizeFunc> kQParamArraySSE2[] = {
   make_tuple(&av1_quantize_fp_c, &av1_quantize_fp_sse2,
              static_cast<TX_SIZE>(TX_16X16), TYPE_FP, AOM_BITS_8),
   make_tuple(&av1_quantize_fp_c, &av1_quantize_fp_sse2,
@@ -537,7 +673,20 @@
 #endif
 
 #if HAVE_NEON
-const QuantizeParam kQParamArrayNEON[] = {
+
+const QuantizeParam<LPQuantizeFunc> kLPQParamArrayNEON[] = {
+  make_tuple(av1_quantize_lp_c, av1_quantize_lp_neon,
+             static_cast<TX_SIZE>(TX_16X16), TYPE_FP, AOM_BITS_8),
+  make_tuple(av1_quantize_lp_c, av1_quantize_lp_neon,
+             static_cast<TX_SIZE>(TX_32X32), TYPE_FP, AOM_BITS_8),
+  make_tuple(av1_quantize_lp_c, av1_quantize_lp_neon,
+             static_cast<TX_SIZE>(TX_64X64), TYPE_FP, AOM_BITS_8)
+};
+
+INSTANTIATE_TEST_SUITE_P(NEON, LowPrecisionQuantizeTest,
+                         ::testing::ValuesIn(kLPQParamArrayNEON));
+
+const QuantizeParam<QuantizeFunc> kQParamArrayNEON[] = {
   make_tuple(&av1_quantize_fp_c, &av1_quantize_fp_neon,
              static_cast<TX_SIZE>(TX_16X16), TYPE_FP, AOM_BITS_8),
   make_tuple(&av1_quantize_fp_c, &av1_quantize_fp_neon,
diff --git a/test/quantize_lp_func_test.cc b/test/quantize_lp_func_test.cc
deleted file mode 100644
index f398623..0000000
--- a/test/quantize_lp_func_test.cc
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
- * Copyright (c) 2021, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include <tuple>
-
-#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
-
-#include "config/aom_config.h"
-#include "config/aom_dsp_rtcd.h"
-#include "config/av1_rtcd.h"
-
-#include "aom/aom_codec.h"
-#include "aom_ports/aom_timer.h"
-#include "av1/encoder/encoder.h"
-#include "av1/common/scan.h"
-#include "test/acm_random.h"
-#include "test/register_state_check.h"
-#include "test/util.h"
-
-namespace {
-using libaom_test::ACMRandom;
-
-#define QUAN_LP_PARAM_LIST                                                 \
-  const int16_t *coeff_ptr, intptr_t n_coeffs, const int16_t *round_ptr,   \
-      const int16_t *quant_ptr, int16_t *qcoeff_ptr, int16_t *dqcoeff_ptr, \
-      const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan,  \
-      const int16_t *iscan
-
-typedef void (*QuantizeFunc)(QUAN_LP_PARAM_LIST);
-
-using std::tuple;
-typedef tuple<QuantizeFunc, QuantizeFunc, TX_SIZE, aom_bit_depth_t>
-    QuantizeParam;
-
-typedef struct {
-  QUANTS quant;
-  Dequants dequant;
-} QuanTable;
-
-const int kTestNum = 1000;
-
-template <typename CoeffType>
-class QuantizeTestBase : public ::testing::TestWithParam<QuantizeParam> {
- protected:
-  QuantizeTestBase()
-      : quant_ref_(GET_PARAM(0)), quant_(GET_PARAM(1)), tx_size_(GET_PARAM(2)),
-        bd_(GET_PARAM(3)) {}
-
-  virtual ~QuantizeTestBase() {}
-
-  virtual void SetUp() {
-    qtab_ = reinterpret_cast<QuanTable *>(aom_memalign(32, sizeof(*qtab_)));
-    const int n_coeffs = coeff_num();
-    coeff_ = reinterpret_cast<CoeffType *>(
-        aom_memalign(32, 6 * n_coeffs * sizeof(CoeffType)));
-    InitQuantizer();
-  }
-
-  virtual void TearDown() {
-    aom_free(qtab_);
-    qtab_ = NULL;
-    aom_free(coeff_);
-    coeff_ = NULL;
-  }
-
-  void InitQuantizer() {
-    av1_build_quantizer(bd_, 0, 0, 0, 0, 0, &qtab_->quant, &qtab_->dequant);
-  }
-
-  virtual void RunQuantizeFunc(const CoeffType *coeff_ptr, intptr_t n_coeffs,
-                               const int16_t *round_ptr,
-                               const int16_t *quant_ptr, CoeffType *qcoeff_ptr,
-                               CoeffType *qcoeff_ref_ptr,
-                               CoeffType *dqcoeff_ptr,
-                               CoeffType *dqcoeff_ref_ptr,
-                               const int16_t *dequant_ptr,
-                               uint16_t *eob_ref_ptr, uint16_t *eob_ptr,
-                               const int16_t *scan, const int16_t *iscan) = 0;
-
-  void QuantizeRun(bool is_loop, int q = 0, int test_num = 1) {
-    CoeffType *coeff_ptr = coeff_;
-    const intptr_t n_coeffs = coeff_num();
-
-    CoeffType *qcoeff_ref = coeff_ptr + n_coeffs;
-    CoeffType *dqcoeff_ref = qcoeff_ref + n_coeffs;
-
-    CoeffType *qcoeff = dqcoeff_ref + n_coeffs;
-    CoeffType *dqcoeff = qcoeff + n_coeffs;
-    uint16_t *eob = (uint16_t *)(dqcoeff + n_coeffs);
-
-    // Testing uses 2-D DCT scan order table
-    const SCAN_ORDER *const sc = get_default_scan(tx_size_, DCT_DCT);
-
-    // Testing uses luminance quantization table
-    const int16_t *round = 0;
-    const int16_t *quant = 0;
-    round = qtab_->quant.y_round_fp[q];
-    quant = qtab_->quant.y_quant_fp[q];
-
-    const int16_t *dequant = qtab_->dequant.y_dequant_QTX[q];
-
-    for (int i = 0; i < test_num; ++i) {
-      if (is_loop) FillCoeffRandom();
-
-      memset(qcoeff_ref, 0, 5 * n_coeffs * sizeof(*qcoeff_ref));
-
-      RunQuantizeFunc(coeff_ptr, n_coeffs, round, quant, qcoeff, qcoeff_ref,
-                      dqcoeff, dqcoeff_ref, dequant, &eob[0], &eob[1], sc->scan,
-                      sc->iscan);
-
-      quant_ref_(coeff_ptr, n_coeffs, round, quant, qcoeff_ref, dqcoeff_ref,
-                 dequant, &eob[0], sc->scan, sc->iscan);
-
-      API_REGISTER_STATE_CHECK(quant_(coeff_ptr, n_coeffs, round, quant, qcoeff,
-                                      dqcoeff, dequant, &eob[1], sc->scan,
-                                      sc->iscan));
-
-      for (int j = 0; j < n_coeffs; ++j) {
-        ASSERT_EQ(qcoeff_ref[j], qcoeff[j])
-            << "Q mismatch on test: " << i << " at position: " << j
-            << " Q: " << q << " coeff: " << coeff_ptr[j];
-      }
-
-      for (int j = 0; j < n_coeffs; ++j) {
-        ASSERT_EQ(dqcoeff_ref[j], dqcoeff[j])
-            << "Dq mismatch on test: " << i << " at position: " << j
-            << " Q: " << q << " coeff: " << coeff_ptr[j];
-      }
-
-      ASSERT_EQ(eob[0], eob[1])
-          << "eobs mismatch on test: " << i << " Q: " << q;
-    }
-  }
-
-  void CompareResults(const CoeffType *buf_ref, const CoeffType *buf, int size,
-                      const char *text, int q, int number) {
-    int i;
-    for (i = 0; i < size; ++i) {
-      ASSERT_EQ(buf_ref[i], buf[i]) << text << " mismatch on test: " << number
-                                    << " at position: " << i << " Q: " << q;
-    }
-  }
-
-  int coeff_num() const { return av1_get_max_eob(tx_size_); }
-
-  void FillCoeff(CoeffType c) {
-    const int n_coeffs = coeff_num();
-    for (int i = 0; i < n_coeffs; ++i) {
-      coeff_[i] = c;
-    }
-  }
-
-  void FillCoeffRandom() {
-    const int n_coeffs = coeff_num();
-    FillCoeffZero();
-    int num = rnd_.Rand16() % n_coeffs;
-    for (int i = 0; i < num; ++i) {
-      coeff_[i] = GetRandomCoeff();
-    }
-  }
-
-  void FillCoeffRandomRows(int num) {
-    FillCoeffZero();
-    for (int i = 0; i < num; ++i) {
-      coeff_[i] = GetRandomCoeff();
-    }
-  }
-
-  void FillCoeffZero() { FillCoeff(0); }
-
-  void FillCoeffConstant() {
-    CoeffType c = GetRandomCoeff();
-    FillCoeff(c);
-  }
-
-  void FillDcOnly() {
-    FillCoeffZero();
-    coeff_[0] = GetRandomCoeff();
-  }
-
-  void FillDcLargeNegative() {
-    FillCoeffZero();
-    // Generate a qcoeff which contains 512/-512 (0x0100/0xFE00) to catch issues
-    // like BUG=883 where the constant being compared was incorrectly
-    // initialized.
-    coeff_[0] = -8191;
-  }
-
-  CoeffType GetRandomCoeff() {
-    CoeffType coeff;
-    if (bd_ == AOM_BITS_8) {
-      coeff =
-          clamp(static_cast<int16_t>(rnd_.Rand16()), INT16_MIN + 1, INT16_MAX);
-    } else {
-      CoeffType min = -(1 << (7 + bd_));
-      CoeffType max = -min - 1;
-      coeff = clamp(static_cast<CoeffType>(rnd_.Rand31()), min, max);
-    }
-    return coeff;
-  }
-
-  ACMRandom rnd_;
-  QuanTable *qtab_;
-  CoeffType *coeff_;
-  QuantizeFunc quant_ref_;
-  QuantizeFunc quant_;
-  TX_SIZE tx_size_;
-  aom_bit_depth_t bd_;
-};
-
-class FullPrecisionQuantizeLpTest : public QuantizeTestBase<int16_t> {
-  void RunQuantizeFunc(const int16_t *coeff_ptr, intptr_t n_coeffs,
-                       const int16_t *round_ptr, const int16_t *quant_ptr,
-                       int16_t *qcoeff_ptr, int16_t *qcoeff_ref_ptr,
-                       int16_t *dqcoeff_ptr, int16_t *dqcoeff_ref_ptr,
-                       const int16_t *dequant_ptr, uint16_t *eob_ref_ptr,
-                       uint16_t *eob_ptr, const int16_t *scan,
-                       const int16_t *iscan) override {
-    quant_ref_(coeff_ptr, n_coeffs, round_ptr, quant_ptr, qcoeff_ref_ptr,
-               dqcoeff_ref_ptr, dequant_ptr, eob_ref_ptr, scan, iscan);
-
-    API_REGISTER_STATE_CHECK(quant_(coeff_ptr, n_coeffs, round_ptr, quant_ptr,
-                                    qcoeff_ptr, dqcoeff_ptr, dequant_ptr,
-                                    eob_ptr, scan, iscan));
-  }
-};
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FullPrecisionQuantizeLpTest);
-
-TEST_P(FullPrecisionQuantizeLpTest, ZeroInput) {
-  FillCoeffZero();
-  QuantizeRun(false);
-}
-
-TEST_P(FullPrecisionQuantizeLpTest, LargeNegativeInput) {
-  FillDcLargeNegative();
-  QuantizeRun(false, 0, 1);
-}
-
-TEST_P(FullPrecisionQuantizeLpTest, DcOnlyInput) {
-  FillDcOnly();
-  QuantizeRun(false, 0, 1);
-}
-
-TEST_P(FullPrecisionQuantizeLpTest, RandomInput) {
-  QuantizeRun(true, 0, kTestNum);
-}
-
-TEST_P(FullPrecisionQuantizeLpTest, MultipleQ) {
-  for (int q = 0; q < QINDEX_RANGE; ++q) {
-    QuantizeRun(true, q, kTestNum);
-  }
-}
-
-// Force the coeff to be half the value of the dequant.  This exposes a
-// mismatch found in av1_quantize_fp_sse2().
-TEST_P(FullPrecisionQuantizeLpTest, CoeffHalfDequant) {
-  FillCoeff(16);
-  QuantizeRun(false, 25, 1);
-}
-
-TEST_P(FullPrecisionQuantizeLpTest, DISABLED_Speed) {
-  int16_t *coeff_ptr = coeff_;
-  const intptr_t n_coeffs = coeff_num();
-
-  int16_t *qcoeff_ref = coeff_ptr + n_coeffs;
-  int16_t *dqcoeff_ref = qcoeff_ref + n_coeffs;
-
-  int16_t *qcoeff = dqcoeff_ref + n_coeffs;
-  int16_t *dqcoeff = qcoeff + n_coeffs;
-  uint16_t *eob = (uint16_t *)(dqcoeff + n_coeffs);
-
-  // Testing uses 2-D DCT scan order table
-  const SCAN_ORDER *const sc = get_default_scan(tx_size_, DCT_DCT);
-
-  // Testing uses luminance quantization table
-  const int q = 22;
-  const int16_t *round_fp = qtab_->quant.y_round_fp[q];
-  const int16_t *quant_fp = qtab_->quant.y_quant_fp[q];
-  const int16_t *dequant = qtab_->dequant.y_dequant_QTX[q];
-  const int kNumTests = 5000000;
-  aom_usec_timer timer, simd_timer;
-  int rows = tx_size_high[tx_size_];
-  int cols = tx_size_wide[tx_size_];
-  rows = AOMMIN(32, rows);
-  cols = AOMMIN(32, cols);
-  for (int cnt = 0; cnt <= rows; cnt++) {
-    FillCoeffRandomRows(cnt * cols);
-
-    aom_usec_timer_start(&timer);
-    for (int n = 0; n < kNumTests; ++n) {
-      quant_ref_(coeff_ptr, n_coeffs, round_fp, quant_fp, qcoeff, dqcoeff,
-                 dequant, eob, sc->scan, sc->iscan);
-    }
-    aom_usec_timer_mark(&timer);
-
-    aom_usec_timer_start(&simd_timer);
-    for (int n = 0; n < kNumTests; ++n) {
-      quant_(coeff_ptr, n_coeffs, round_fp, quant_fp, qcoeff, dqcoeff, dequant,
-             eob, sc->scan, sc->iscan);
-    }
-    aom_usec_timer_mark(&simd_timer);
-
-    const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
-    const int simd_elapsed_time =
-        static_cast<int>(aom_usec_timer_elapsed(&simd_timer));
-    printf("c_time = %d \t simd_time = %d \t Gain = %f \n", elapsed_time,
-           simd_elapsed_time, ((float)elapsed_time / simd_elapsed_time));
-  }
-}
-
-using std::make_tuple;
-
-#if HAVE_AVX2
-const QuantizeParam kQParamArrayAVX2[] = {
-  // av1_quantize_lp is only called in nonrd_pickmode.c, and is used for 16X16,
-  // 8X8, and 4X4.
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_avx2,
-             static_cast<TX_SIZE>(TX_16X16), AOM_BITS_8),
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_avx2,
-             static_cast<TX_SIZE>(TX_8X8), AOM_BITS_8),
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_avx2,
-             static_cast<TX_SIZE>(TX_4X4), AOM_BITS_8)
-};
-
-INSTANTIATE_TEST_SUITE_P(AVX2, FullPrecisionQuantizeLpTest,
-                         ::testing::ValuesIn(kQParamArrayAVX2));
-#endif
-
-#if HAVE_SSE2
-const QuantizeParam kQParamArraySSE2[] = {
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_sse2,
-             static_cast<TX_SIZE>(TX_16X16), AOM_BITS_8),
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_sse2,
-             static_cast<TX_SIZE>(TX_8X8), AOM_BITS_8),
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_sse2,
-             static_cast<TX_SIZE>(TX_4X4), AOM_BITS_8)
-};
-
-INSTANTIATE_TEST_SUITE_P(SSE2, FullPrecisionQuantizeLpTest,
-                         ::testing::ValuesIn(kQParamArraySSE2));
-#endif
-
-#if HAVE_NEON
-const QuantizeParam kQParamArrayNEON[] = {
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_neon,
-             static_cast<TX_SIZE>(TX_16X16), AOM_BITS_8),
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_neon,
-             static_cast<TX_SIZE>(TX_8X8), AOM_BITS_8),
-  make_tuple(&av1_quantize_lp_c, &av1_quantize_lp_neon,
-             static_cast<TX_SIZE>(TX_4X4), AOM_BITS_8)
-};
-
-INSTANTIATE_TEST_SUITE_P(NEON, FullPrecisionQuantizeLpTest,
-                         ::testing::ValuesIn(kQParamArrayNEON));
-#endif
-
-}  // namespace
diff --git a/test/test.cmake b/test/test.cmake
index 3efcfac..9f58511 100644
--- a/test/test.cmake
+++ b/test/test.cmake
@@ -277,7 +277,6 @@
               "${AOM_ROOT}/test/obmc_variance_test.cc"
               "${AOM_ROOT}/test/pickrst_test.cc"
               "${AOM_ROOT}/test/quantize_func_test.cc"
-              "${AOM_ROOT}/test/quantize_lp_func_test.cc"
               "${AOM_ROOT}/test/sad_test.cc"
               "${AOM_ROOT}/test/subtract_test.cc"
               "${AOM_ROOT}/test/reconinter_test.cc"
@@ -324,8 +323,7 @@
 
   if(NOT (HAVE_SSE2 OR HAVE_NEON))
     list(REMOVE_ITEM AOM_UNIT_TEST_ENCODER_SOURCES
-                     "${AOM_ROOT}/test/quantize_func_test.cc"
-                     "${AOM_ROOT}/test/quantize_lp_func_test.cc")
+                     "${AOM_ROOT}/test/quantize_func_test.cc")
   endif()
 
   if(HAVE_SSE4_1)