shithub: libvpx

Download patch

ref: b358f9076f153835680cd3af3765c7e30474c030
parent: dbe00bb68b8a67beed66aae866b90296ed311412
author: Jerome Jiang <jianj@google.com>
date: Thu Jul 23 12:46:01 EDT 2020

NULL -> nullptr in CPP files

This should clean up clangtidy warnings

Change-Id: Ifb5a986121b2d0bd71b9ad39a79dd46c63bdb998

--- a/test/active_map_refresh_test.cc
+++ b/test/active_map_refresh_test.cc
@@ -80,7 +80,7 @@
     } else if (video->frame() >= 2 && video->img()) {
       vpx_image_t *current = video->img();
       vpx_image_t *previous = y4m_holder_->img();
-      ASSERT_TRUE(previous != NULL);
+      ASSERT_NE(previous, nullptr);
       vpx_active_map_t map = vpx_active_map_t();
       const int width = static_cast<int>(current->d_w);
       const int height = static_cast<int>(current->d_h);
--- a/test/active_map_test.cc
+++ b/test/active_map_test.cc
@@ -62,7 +62,7 @@
       vpx_active_map_t map = vpx_active_map_t();
       map.cols = (kWidth + 15) / 16;
       map.rows = (kHeight + 15) / 16;
-      map.active_map = NULL;
+      map.active_map = nullptr;
       encoder->Control(VP8E_SET_ACTIVEMAP, &map);
     }
   }
--- a/test/add_noise_test.cc
+++ b/test/add_noise_test.cc
@@ -53,7 +53,7 @@
   const int clamp = vpx_setup_noise(GET_PARAM(0), noise, kNoiseSize);
   uint8_t *const s =
       reinterpret_cast<uint8_t *>(vpx_calloc(image_size, sizeof(*s)));
-  ASSERT_TRUE(s != NULL);
+  ASSERT_NE(s, nullptr);
   memset(s, 99, image_size * sizeof(*s));
 
   ASM_REGISTER_STATE_CHECK(
@@ -106,8 +106,8 @@
 
   uint8_t *const s = reinterpret_cast<uint8_t *>(vpx_calloc(image_size, 1));
   uint8_t *const d = reinterpret_cast<uint8_t *>(vpx_calloc(image_size, 1));
-  ASSERT_TRUE(s != NULL);
-  ASSERT_TRUE(d != NULL);
+  ASSERT_NE(s, nullptr);
+  ASSERT_NE(d, nullptr);
 
   memset(s, 99, image_size);
   memset(d, 99, image_size);
--- a/test/avg_test.cc
+++ b/test/avg_test.cc
@@ -35,12 +35,12 @@
 class AverageTestBase : public ::testing::Test {
  public:
   AverageTestBase(int width, int height)
-      : width_(width), height_(height), source_data_(NULL), source_stride_(0),
-        bit_depth_(8) {}
+      : width_(width), height_(height), source_data_(nullptr),
+        source_stride_(0), bit_depth_(8) {}
 
   virtual void TearDown() {
     vpx_free(source_data_);
-    source_data_ = NULL;
+    source_data_ = nullptr;
     libvpx_test::ClearSystemState();
   }
 
@@ -52,7 +52,7 @@
   virtual void SetUp() {
     source_data_ = reinterpret_cast<Pixel *>(
         vpx_memalign(kDataAlignment, kDataBlockSize * sizeof(source_data_[0])));
-    ASSERT_TRUE(source_data_ != NULL);
+    ASSERT_NE(source_data_, nullptr);
     source_stride_ = (width_ + 31) & ~31;
     bit_depth_ = 8;
     rnd_.Reset(ACMRandom::DeterministicSeed());
@@ -162,7 +162,8 @@
                       public ::testing::WithParamInterface<IntProRowParam> {
  public:
   IntProRowTest()
-      : AverageTestBase(16, GET_PARAM(0)), hbuf_asm_(NULL), hbuf_c_(NULL) {
+      : AverageTestBase(16, GET_PARAM(0)), hbuf_asm_(nullptr),
+        hbuf_c_(nullptr) {
     asm_func_ = GET_PARAM(1);
     c_func_ = GET_PARAM(2);
   }
@@ -171,7 +172,7 @@
   virtual void SetUp() {
     source_data_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(kDataAlignment, kDataBlockSize * sizeof(source_data_[0])));
-    ASSERT_TRUE(source_data_ != NULL);
+    ASSERT_NE(source_data_, nullptr);
 
     hbuf_asm_ = reinterpret_cast<int16_t *>(
         vpx_memalign(kDataAlignment, sizeof(*hbuf_asm_) * 16));
@@ -181,11 +182,11 @@
 
   virtual void TearDown() {
     vpx_free(source_data_);
-    source_data_ = NULL;
+    source_data_ = nullptr;
     vpx_free(hbuf_c_);
-    hbuf_c_ = NULL;
+    hbuf_c_ = nullptr;
     vpx_free(hbuf_asm_);
-    hbuf_asm_ = NULL;
+    hbuf_asm_ = nullptr;
   }
 
   void RunComparison() {
@@ -241,7 +242,7 @@
     rnd_.Reset(ACMRandom::DeterministicSeed());
     src_ = reinterpret_cast<tran_low_t *>(
         vpx_memalign(16, sizeof(*src_) * satd_size_));
-    ASSERT_TRUE(src_ != NULL);
+    ASSERT_NE(src_, nullptr);
   }
 
   virtual void TearDown() {
@@ -297,8 +298,8 @@
         vpx_memalign(16, sizeof(*coeff_) * txfm_size_));
     dqcoeff_ = reinterpret_cast<tran_low_t *>(
         vpx_memalign(16, sizeof(*dqcoeff_) * txfm_size_));
-    ASSERT_TRUE(coeff_ != NULL);
-    ASSERT_TRUE(dqcoeff_ != NULL);
+    ASSERT_NE(coeff_, nullptr);
+    ASSERT_NE(dqcoeff_, nullptr);
   }
 
   virtual void TearDown() {
--- a/test/blockiness_test.cc
+++ b/test/blockiness_test.cc
@@ -44,9 +44,9 @@
 
   static void TearDownTestSuite() {
     vpx_free(source_data_);
-    source_data_ = NULL;
+    source_data_ = nullptr;
     vpx_free(reference_data_);
-    reference_data_ = NULL;
+    reference_data_ = nullptr;
   }
 
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
@@ -154,8 +154,8 @@
 };
 #endif  // CONFIG_VP9_ENCODER
 
-uint8_t *BlockinessTestBase::source_data_ = NULL;
-uint8_t *BlockinessTestBase::reference_data_ = NULL;
+uint8_t *BlockinessTestBase::source_data_ = nullptr;
+uint8_t *BlockinessTestBase::reference_data_ = nullptr;
 
 #if CONFIG_VP9_ENCODER
 TEST_P(BlockinessVP9Test, SourceBlockierThanReference) {
--- a/test/byte_alignment_test.cc
+++ b/test/byte_alignment_test.cc
@@ -55,23 +55,24 @@
 class ByteAlignmentTest
     : public ::testing::TestWithParam<ByteAlignmentTestParam> {
  protected:
-  ByteAlignmentTest() : video_(NULL), decoder_(NULL), md5_file_(NULL) {}
+  ByteAlignmentTest()
+      : video_(nullptr), decoder_(nullptr), md5_file_(nullptr) {}
 
   virtual void SetUp() {
     video_ = new libvpx_test::WebMVideoSource(kVP9TestFile);
-    ASSERT_TRUE(video_ != NULL);
+    ASSERT_NE(video_, nullptr);
     video_->Init();
     video_->Begin();
 
     const vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
     decoder_ = new libvpx_test::VP9Decoder(cfg, 0);
-    ASSERT_TRUE(decoder_ != NULL);
+    ASSERT_NE(decoder_, nullptr);
 
     OpenMd5File(kVP9Md5File);
   }
 
   virtual void TearDown() {
-    if (md5_file_ != NULL) fclose(md5_file_);
+    if (md5_file_ != nullptr) fclose(md5_file_);
 
     delete decoder_;
     delete video_;
@@ -90,7 +91,7 @@
   }
 
   vpx_codec_err_t DecodeRemainingFrames(int byte_alignment_to_check) {
-    for (; video_->cxdata() != NULL; video_->Next()) {
+    for (; video_->cxdata() != nullptr; video_->Next()) {
       const vpx_codec_err_t res =
           decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
       if (res != VPX_CODEC_OK) return res;
@@ -113,7 +114,7 @@
     const vpx_image_t *img;
 
     // Get decompressed data
-    while ((img = dec_iter.Next()) != NULL) {
+    while ((img = dec_iter.Next()) != nullptr) {
       if (byte_alignment_to_check == kLegacyByteAlignment) {
         CheckByteAlignment(img->planes[0], kLegacyYPlaneByteAlignment);
       } else {
@@ -128,12 +129,12 @@
   // TODO(fgalligan): Move the MD5 testing code into another class.
   void OpenMd5File(const std::string &md5_file_name_) {
     md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_);
-    ASSERT_TRUE(md5_file_ != NULL)
+    ASSERT_NE(md5_file_, nullptr)
         << "MD5 file open failed. Filename: " << md5_file_name_;
   }
 
   void CheckMd5(const vpx_image_t &img) {
-    ASSERT_TRUE(md5_file_ != NULL);
+    ASSERT_NE(md5_file_, nullptr);
     char expected_md5[33];
     char junk[128];
 
--- a/test/comp_avg_pred_test.cc
+++ b/test/comp_avg_pred_test.cc
@@ -29,9 +29,9 @@
 
 void reference_pred(const Buffer<uint8_t> &pred, const Buffer<uint8_t> &ref,
                     int width, int height, Buffer<uint8_t> *avg) {
-  ASSERT_TRUE(avg->TopLeftPixel() != NULL);
-  ASSERT_TRUE(pred.TopLeftPixel() != NULL);
-  ASSERT_TRUE(ref.TopLeftPixel() != NULL);
+  ASSERT_NE(avg->TopLeftPixel(), nullptr);
+  ASSERT_NE(pred.TopLeftPixel(), nullptr);
+  ASSERT_NE(ref.TopLeftPixel(), nullptr);
 
   for (int y = 0; y < height; ++y) {
     for (int x = 0; x < width; ++x) {
--- a/test/consistency_test.cc
+++ b/test/consistency_test.cc
@@ -54,13 +54,13 @@
   static void ClearSsim() { memset(ssim_array_, 0, kDataBufferSize / 16); }
   static void TearDownTestSuite() {
     vpx_free(source_data_[0]);
-    source_data_[0] = NULL;
+    source_data_[0] = nullptr;
     vpx_free(reference_data_[0]);
-    reference_data_[0] = NULL;
+    reference_data_[0] = nullptr;
     vpx_free(source_data_[1]);
-    source_data_[1] = NULL;
+    source_data_[1] = nullptr;
     vpx_free(reference_data_[1]);
-    reference_data_[1] = NULL;
+    reference_data_[1] = nullptr;
 
     delete[] ssim_array_;
   }
@@ -145,9 +145,9 @@
 };
 #endif  // CONFIG_VP9_ENCODER
 
-uint8_t *ConsistencyTestBase::source_data_[2] = { NULL, NULL };
-uint8_t *ConsistencyTestBase::reference_data_[2] = { NULL, NULL };
-Ssimv *ConsistencyTestBase::ssim_array_ = NULL;
+uint8_t *ConsistencyTestBase::source_data_[2] = { nullptr, nullptr };
+uint8_t *ConsistencyTestBase::reference_data_[2] = { nullptr, nullptr };
+Ssimv *ConsistencyTestBase::ssim_array_ = nullptr;
 
 #if CONFIG_VP9_ENCODER
 TEST_P(ConsistencyVP9Test, ConsistencyIsZero) {
--- a/test/convolve_test.cc
+++ b/test/convolve_test.cc
@@ -365,18 +365,18 @@
 
   static void TearDownTestSuite() {
     vpx_free(input_ - 1);
-    input_ = NULL;
+    input_ = nullptr;
     vpx_free(output_);
-    output_ = NULL;
+    output_ = nullptr;
     vpx_free(output_ref_);
-    output_ref_ = NULL;
+    output_ref_ = nullptr;
 #if CONFIG_VP9_HIGHBITDEPTH
     vpx_free(input16_ - 1);
-    input16_ = NULL;
+    input16_ = nullptr;
     vpx_free(output16_);
-    output16_ = NULL;
+    output16_ = nullptr;
     vpx_free(output16_ref_);
-    output16_ref_ = NULL;
+    output16_ref_ = nullptr;
 #endif
   }
 
@@ -541,13 +541,13 @@
 #endif
 };
 
-uint8_t *ConvolveTest::input_ = NULL;
-uint8_t *ConvolveTest::output_ = NULL;
-uint8_t *ConvolveTest::output_ref_ = NULL;
+uint8_t *ConvolveTest::input_ = nullptr;
+uint8_t *ConvolveTest::output_ = nullptr;
+uint8_t *ConvolveTest::output_ref_ = nullptr;
 #if CONFIG_VP9_HIGHBITDEPTH
-uint16_t *ConvolveTest::input16_ = NULL;
-uint16_t *ConvolveTest::output16_ = NULL;
-uint16_t *ConvolveTest::output16_ref_ = NULL;
+uint16_t *ConvolveTest::input16_ = nullptr;
+uint16_t *ConvolveTest::output16_ = nullptr;
+uint16_t *ConvolveTest::output16_ref_ = nullptr;
 #endif
 
 TEST_P(ConvolveTest, GuardBlocks) { CheckGuardBlocks(); }
@@ -562,7 +562,7 @@
 
   vpx_usec_timer_start(&timer);
   for (int n = 0; n < kNumTests; ++n) {
-    UUT_->copy_[0](in, kInputStride, out, kOutputStride, NULL, 0, 0, 0, 0,
+    UUT_->copy_[0](in, kInputStride, out, kOutputStride, nullptr, 0, 0, 0, 0,
                    width, height);
   }
   vpx_usec_timer_mark(&timer);
@@ -582,7 +582,7 @@
 
   vpx_usec_timer_start(&timer);
   for (int n = 0; n < kNumTests; ++n) {
-    UUT_->copy_[1](in, kInputStride, out, kOutputStride, NULL, 0, 0, 0, 0,
+    UUT_->copy_[1](in, kInputStride, out, kOutputStride, nullptr, 0, 0, 0, 0,
                    width, height);
   }
   vpx_usec_timer_mark(&timer);
@@ -780,7 +780,8 @@
   uint8_t *const out = output();
 
   ASM_REGISTER_STATE_CHECK(UUT_->copy_[0](in, kInputStride, out, kOutputStride,
-                                          NULL, 0, 0, 0, 0, Width(), Height()));
+                                          nullptr, 0, 0, 0, 0, Width(),
+                                          Height()));
 
   CheckGuardBlocks();
 
@@ -799,7 +800,8 @@
   CopyOutputToRef();
 
   ASM_REGISTER_STATE_CHECK(UUT_->copy_[1](in, kInputStride, out, kOutputStride,
-                                          NULL, 0, 0, 0, 0, Width(), Height()));
+                                          nullptr, 0, 0, 0, 0, Width(),
+                                          Height()));
 
   CheckGuardBlocks();
 
@@ -955,9 +957,9 @@
                 UUT_->h8_[i](in, kInputStride, out, kOutputStride, filters,
                              filter_x, 16, 0, 16, Width(), Height()));
           else
-            ASM_REGISTER_STATE_CHECK(UUT_->copy_[i](in, kInputStride, out,
-                                                    kOutputStride, NULL, 0, 0,
-                                                    0, 0, Width(), Height()));
+            ASM_REGISTER_STATE_CHECK(
+                UUT_->copy_[i](in, kInputStride, out, kOutputStride, nullptr, 0,
+                               0, 0, 0, Width(), Height()));
 
           CheckGuardBlocks();
 
@@ -1053,9 +1055,9 @@
                   UUT_->h8_[0](in, kInputStride, out, kOutputStride, filters,
                                filter_x, 16, 0, 16, Width(), Height()));
             else
-              ASM_REGISTER_STATE_CHECK(UUT_->copy_[0](in, kInputStride, out,
-                                                      kOutputStride, NULL, 0, 0,
-                                                      0, 0, Width(), Height()));
+              ASM_REGISTER_STATE_CHECK(
+                  UUT_->copy_[0](in, kInputStride, out, kOutputStride, nullptr,
+                                 0, 0, 0, 0, Width(), Height()));
 
             for (int y = 0; y < Height(); ++y) {
               for (int x = 0; x < Width(); ++x)
--- a/test/dct_partial_test.cc
+++ b/test/dct_partial_test.cc
@@ -39,7 +39,7 @@
 
 tran_low_t partial_fdct_ref(const Buffer<int16_t> &in, int size) {
   int64_t sum = 0;
-  if (in.TopLeftPixel() != NULL) {
+  if (in.TopLeftPixel() != nullptr) {
     for (int y = 0; y < size; ++y) {
       for (int x = 0; x < size; ++x) {
         sum += in.TopLeftPixel()[y * in.stride() + x];
@@ -81,7 +81,7 @@
     Buffer<tran_low_t> output_block = Buffer<tran_low_t>(size_, size_, 0, 16);
     ASSERT_TRUE(output_block.Init());
 
-    if (output_block.TopLeftPixel() != NULL) {
+    if (output_block.TopLeftPixel() != nullptr) {
       for (int i = 0; i < 100; ++i) {
         if (i == 0) {
           input_block.Set(maxvalue);
--- a/test/dct_test.cc
+++ b/test/dct_test.cc
@@ -160,17 +160,17 @@
 
     src_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(16, pixel_size_ * block_size_));
-    ASSERT_TRUE(src_ != NULL);
+    ASSERT_NE(src_, nullptr);
     dst_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(16, pixel_size_ * block_size_));
-    ASSERT_TRUE(dst_ != NULL);
+    ASSERT_NE(dst_, nullptr);
   }
 
   virtual void TearDown() {
     vpx_free(src_);
-    src_ = NULL;
+    src_ = nullptr;
     vpx_free(dst_);
-    dst_ = NULL;
+    dst_ = nullptr;
     libvpx_test::ClearSystemState();
   }
 
@@ -211,7 +211,7 @@
     Buffer<int16_t> test_input_block =
         Buffer<int16_t>(size_, size_, 8, size_ == 4 ? 0 : 16);
     ASSERT_TRUE(test_input_block.Init());
-    ASSERT_TRUE(test_input_block.TopLeftPixel() != NULL);
+    ASSERT_NE(test_input_block.TopLeftPixel(), nullptr);
     Buffer<tran_low_t> test_temp_block =
         Buffer<tran_low_t>(size_, size_, 0, 16);
     ASSERT_TRUE(test_temp_block.Init());
@@ -316,7 +316,7 @@
       } else if (i == 1) {
         input_extreme_block.Set(-max_pixel_value_);
       } else {
-        ASSERT_TRUE(input_extreme_block.TopLeftPixel() != NULL);
+        ASSERT_NE(input_extreme_block.TopLeftPixel(), nullptr);
         for (int h = 0; h < size_; ++h) {
           for (int w = 0; w < size_; ++w) {
             input_extreme_block
@@ -331,7 +331,7 @@
 
       // The minimum quant value is 4.
       EXPECT_TRUE(output_block.CheckValues(output_ref_block));
-      ASSERT_TRUE(output_block.TopLeftPixel() != NULL);
+      ASSERT_NE(output_block.TopLeftPixel(), nullptr);
       for (int h = 0; h < size_; ++h) {
         for (int w = 0; w < size_; ++w) {
           EXPECT_GE(
@@ -369,7 +369,7 @@
 
     for (int i = 0; i < count_test_block; ++i) {
       InitMem();
-      ASSERT_TRUE(in.TopLeftPixel() != NULL);
+      ASSERT_NE(in.TopLeftPixel(), nullptr);
       // Initialize a test block with input range [-max_pixel_value_,
       // max_pixel_value_].
       for (int h = 0; h < size_; ++h) {
--- a/test/decode_perf_test.cc
+++ b/test/decode_perf_test.cc
@@ -87,7 +87,7 @@
   vpx_usec_timer t;
   vpx_usec_timer_start(&t);
 
-  for (video.Begin(); video.cxdata() != NULL; video.Next()) {
+  for (video.Begin(); video.cxdata() != nullptr; video.Next()) {
     decoder.DecodeFrame(video.cxdata(), video.frame_size());
   }
 
@@ -150,16 +150,16 @@
     const std::string data_path = getenv("LIBVPX_TEST_DATA_PATH");
     const std::string path_to_source = data_path + "/" + kNewEncodeOutputFile;
     outfile_ = fopen(path_to_source.c_str(), "wb");
-    ASSERT_TRUE(outfile_ != NULL);
+    ASSERT_NE(outfile_, nullptr);
   }
 
   virtual void EndPassHook() {
-    if (outfile_ != NULL) {
+    if (outfile_ != nullptr) {
       if (!fseek(outfile_, 0, SEEK_SET)) {
         ivf_write_file_header(outfile_, &cfg_, VP9_FOURCC, out_frames_);
       }
       fclose(outfile_);
-      outfile_ = NULL;
+      outfile_ = nullptr;
     }
   }
 
@@ -236,7 +236,7 @@
   vpx_usec_timer t;
   vpx_usec_timer_start(&t);
 
-  for (decode_video.Begin(); decode_video.cxdata() != NULL;
+  for (decode_video.Begin(); decode_video.cxdata() != nullptr;
        decode_video.Next()) {
     decoder.DecodeFrame(decode_video.cxdata(), decode_video.frame_size());
   }
--- a/test/decode_svc_test.cc
+++ b/test/decode_svc_test.cc
@@ -56,7 +56,7 @@
   const std::string filename = GET_PARAM(1);
   std::unique_ptr<libvpx_test::CompressedVideoSource> video;
   video.reset(new libvpx_test::IVFVideoSource(filename));
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
   video->Init();
   total_frames_ = 0;
   spatial_layer_ = 0;
@@ -73,7 +73,7 @@
   const std::string filename = GET_PARAM(1);
   std::unique_ptr<libvpx_test::CompressedVideoSource> video;
   video.reset(new libvpx_test::IVFVideoSource(filename));
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
   video->Init();
   total_frames_ = 0;
   spatial_layer_ = 1;
@@ -90,7 +90,7 @@
   const std::string filename = GET_PARAM(1);
   std::unique_ptr<libvpx_test::CompressedVideoSource> video;
   video.reset(new libvpx_test::IVFVideoSource(filename));
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
   video->Init();
   total_frames_ = 0;
   spatial_layer_ = 2;
@@ -108,7 +108,7 @@
   const std::string filename = GET_PARAM(1);
   std::unique_ptr<libvpx_test::CompressedVideoSource> video;
   video.reset(new libvpx_test::IVFVideoSource(filename));
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
   video->Init();
   total_frames_ = 0;
   spatial_layer_ = 10;
--- a/test/decode_test_driver.cc
+++ b/test/decode_test_driver.cc
@@ -26,7 +26,7 @@
 }
 
 vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size) {
-  return DecodeFrame(cxdata, size, NULL);
+  return DecodeFrame(cxdata, size, nullptr);
 }
 
 vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size,
@@ -67,7 +67,7 @@
 void DecoderTest::RunLoop(CompressedVideoSource *video,
                           const vpx_codec_dec_cfg_t &dec_cfg) {
   Decoder *const decoder = codec_->CreateDecoder(dec_cfg, flags_);
-  ASSERT_TRUE(decoder != NULL);
+  ASSERT_NE(decoder, nullptr);
   bool end_of_file = false;
 
   // Decode frames.
@@ -78,7 +78,7 @@
     vpx_codec_stream_info_t stream_info;
     stream_info.sz = sizeof(stream_info);
 
-    if (video->cxdata() != NULL) {
+    if (video->cxdata() != nullptr) {
       const vpx_codec_err_t res_peek = decoder->PeekStream(
           video->cxdata(), video->frame_size(), &stream_info);
       HandlePeekResult(decoder, video, res_peek);
@@ -89,13 +89,13 @@
       if (!HandleDecodeResult(res_dec, *video, decoder)) break;
     } else {
       // Signal end of the file to the decoder.
-      const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
+      const vpx_codec_err_t res_dec = decoder->DecodeFrame(nullptr, 0);
       ASSERT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
       end_of_file = true;
     }
 
     DxDataIterator dec_iter = decoder->GetDxData();
-    const vpx_image_t *img = NULL;
+    const vpx_image_t *img = nullptr;
 
     // Get decompressed data
     while (!::testing::Test::HasFailure() && (img = dec_iter.Next())) {
--- a/test/encode_api_test.cc
+++ b/test/encode_api_test.cc
@@ -34,29 +34,33 @@
 
   EXPECT_EQ(&img, vpx_img_wrap(&img, VPX_IMG_FMT_I420, 1, 1, 1, buf));
 
-  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_enc_init(NULL, NULL, NULL, 0));
-  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_enc_init(&enc, NULL, NULL, 0));
-  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_encode(NULL, NULL, 0, 0, 0, 0));
-  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_encode(NULL, &img, 0, 0, 0, 0));
-  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_destroy(NULL));
   EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
-            vpx_codec_enc_config_default(NULL, NULL, 0));
+            vpx_codec_enc_init(nullptr, nullptr, nullptr, 0));
   EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
-            vpx_codec_enc_config_default(NULL, &cfg, 0));
-  EXPECT_TRUE(vpx_codec_error(NULL) != NULL);
+            vpx_codec_enc_init(&enc, nullptr, nullptr, 0));
+  EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
+            vpx_codec_encode(nullptr, nullptr, 0, 0, 0, 0));
+  EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
+            vpx_codec_encode(nullptr, &img, 0, 0, 0, 0));
+  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_destroy(nullptr));
+  EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
+            vpx_codec_enc_config_default(nullptr, nullptr, 0));
+  EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
+            vpx_codec_enc_config_default(nullptr, &cfg, 0));
+  EXPECT_NE(vpx_codec_error(nullptr), nullptr);
 
   for (int i = 0; i < NELEMENTS(kCodecs); ++i) {
     SCOPED_TRACE(vpx_codec_iface_name(kCodecs[i]));
     EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
-              vpx_codec_enc_init(NULL, kCodecs[i], NULL, 0));
+              vpx_codec_enc_init(nullptr, kCodecs[i], nullptr, 0));
     EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
-              vpx_codec_enc_init(&enc, kCodecs[i], NULL, 0));
+              vpx_codec_enc_init(&enc, kCodecs[i], nullptr, 0));
     EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
               vpx_codec_enc_config_default(kCodecs[i], &cfg, 1));
 
     EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_config_default(kCodecs[i], &cfg, 0));
     EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_init(&enc, kCodecs[i], &cfg, 0));
-    EXPECT_EQ(VPX_CODEC_OK, vpx_codec_encode(&enc, NULL, 0, 0, 0, 0));
+    EXPECT_EQ(VPX_CODEC_OK, vpx_codec_encode(&enc, nullptr, 0, 0, 0, 0));
 
     EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&enc));
   }
--- a/test/encode_test_driver.cc
+++ b/test/encode_test_driver.cc
@@ -91,7 +91,7 @@
 
 void Encoder::Flush() {
   const vpx_codec_err_t res =
-      vpx_codec_encode(&encoder_, NULL, 0, 0, 0, deadline_);
+      vpx_codec_encode(&encoder_, nullptr, 0, 0, 0, deadline_);
   if (!encoder_.priv)
     ASSERT_EQ(VPX_CODEC_ERROR, res) << EncoderError();
   else
@@ -182,7 +182,7 @@
     BeginPassHook(pass);
     std::unique_ptr<Encoder> encoder(
         codec_->CreateEncoder(cfg_, deadline_, init_flags_, &stats_));
-    ASSERT_TRUE(encoder.get() != NULL);
+    ASSERT_NE(encoder.get(), nullptr);
 
     ASSERT_NO_FATAL_FAILURE(video->Begin());
     encoder->InitEncoder(video);
@@ -198,7 +198,7 @@
         codec_->CreateDecoder(dec_cfg, dec_init_flags));
     bool again;
     for (again = true; again; video->Next()) {
-      again = (video->img() != NULL);
+      again = (video->img() != nullptr);
 
       PreEncodeFrameHook(video);
       PreEncodeFrameHook(video, encoder.get());
@@ -216,7 +216,7 @@
         switch (pkt->kind) {
           case VPX_CODEC_CX_FRAME_PKT:
             has_cxdata = true;
-            if (decoder.get() != NULL && DoDecode()) {
+            if (decoder.get() != nullptr && DoDecode()) {
               PreDecodeFrameHook(video, decoder.get());
               vpx_codec_err_t res_dec = decoder->DecodeFrame(
                   (const uint8_t *)pkt->data.frame.buf, pkt->data.frame.sz);
@@ -240,7 +240,7 @@
 
       // Flush the decoder when there are no more fragments.
       if ((init_flags_ & VPX_CODEC_USE_OUTPUT_PARTITION) && has_dxdata) {
-        const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
+        const vpx_codec_err_t res_dec = decoder->DecodeFrame(nullptr, 0);
         if (!HandleDecodeResult(res_dec, *video, decoder.get())) break;
       }
 
--- a/test/external_frame_buffer_test.cc
+++ b/test/external_frame_buffer_test.cc
@@ -36,7 +36,7 @@
 class ExternalFrameBufferList {
  public:
   ExternalFrameBufferList()
-      : num_buffers_(0), num_used_buffers_(0), ext_fb_list_(NULL) {}
+      : num_buffers_(0), num_used_buffers_(0), ext_fb_list_(nullptr) {}
 
   virtual ~ExternalFrameBufferList() {
     for (int i = 0; i < num_buffers_; ++i) {
@@ -51,7 +51,7 @@
 
     num_buffers_ = num_buffers;
     ext_fb_list_ = new ExternalFrameBuffer[num_buffers_];
-    EXPECT_TRUE(ext_fb_list_ != NULL);
+    EXPECT_NE(ext_fb_list_, nullptr);
     memset(ext_fb_list_, 0, sizeof(ext_fb_list_[0]) * num_buffers_);
     return true;
   }
@@ -61,7 +61,7 @@
   // frame buffer is in use by libvpx. Finally sets |fb| to point to the
   // external frame buffer. Returns < 0 on an error.
   int GetFreeFrameBuffer(size_t min_size, vpx_codec_frame_buffer_t *fb) {
-    EXPECT_TRUE(fb != NULL);
+    EXPECT_NE(fb, nullptr);
     const int idx = FindFreeBufferIndex();
     if (idx == num_buffers_) return -1;
 
@@ -81,13 +81,13 @@
   // Test function that will not allocate any data for the frame buffer.
   // Returns < 0 on an error.
   int GetZeroFrameBuffer(size_t min_size, vpx_codec_frame_buffer_t *fb) {
-    EXPECT_TRUE(fb != NULL);
+    EXPECT_NE(fb, nullptr);
     const int idx = FindFreeBufferIndex();
     if (idx == num_buffers_) return -1;
 
     if (ext_fb_list_[idx].size < min_size) {
       delete[] ext_fb_list_[idx].data;
-      ext_fb_list_[idx].data = NULL;
+      ext_fb_list_[idx].data = nullptr;
       ext_fb_list_[idx].size = min_size;
     }
 
@@ -98,14 +98,14 @@
   // Marks the external frame buffer that |fb| is pointing to as free.
   // Returns < 0 on an error.
   int ReturnFrameBuffer(vpx_codec_frame_buffer_t *fb) {
-    if (fb == NULL) {
-      EXPECT_TRUE(fb != NULL);
+    if (fb == nullptr) {
+      EXPECT_NE(fb, nullptr);
       return -1;
     }
     ExternalFrameBuffer *const ext_fb =
         reinterpret_cast<ExternalFrameBuffer *>(fb->priv);
-    if (ext_fb == NULL) {
-      EXPECT_TRUE(ext_fb != NULL);
+    if (ext_fb == nullptr) {
+      EXPECT_NE(ext_fb, nullptr);
       return -1;
     }
     EXPECT_EQ(1, ext_fb->in_use);
@@ -117,7 +117,7 @@
   // Checks that the vpx_image_t data is contained within the external frame
   // buffer private data passed back in the vpx_image_t.
   void CheckImageFrameBuffer(const vpx_image_t *img) {
-    if (img->fb_priv != NULL) {
+    if (img->fb_priv != nullptr) {
       const struct ExternalFrameBuffer *const ext_fb =
           reinterpret_cast<ExternalFrameBuffer *>(img->fb_priv);
 
@@ -143,7 +143,7 @@
   // Sets |fb| to an external frame buffer. idx is the index into the frame
   // buffer list.
   void SetFrameBuffer(int idx, vpx_codec_frame_buffer_t *fb) {
-    ASSERT_TRUE(fb != NULL);
+    ASSERT_NE(fb, nullptr);
     fb->data = ext_fb_list_[idx].data;
     fb->size = ext_fb_list_[idx].size;
     ASSERT_EQ(0, ext_fb_list_[idx].in_use);
@@ -208,10 +208,10 @@
  protected:
   ExternalFrameBufferMD5Test()
       : DecoderTest(GET_PARAM(::libvpx_test::kCodecFactoryParam)),
-        md5_file_(NULL), num_buffers_(0) {}
+        md5_file_(nullptr), num_buffers_(0) {}
 
   virtual ~ExternalFrameBufferMD5Test() {
-    if (md5_file_ != NULL) fclose(md5_file_);
+    if (md5_file_ != nullptr) fclose(md5_file_);
   }
 
   virtual void PreDecodeFrameHook(
@@ -228,13 +228,13 @@
 
   void OpenMD5File(const std::string &md5_file_name_) {
     md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_);
-    ASSERT_TRUE(md5_file_ != NULL)
+    ASSERT_NE(md5_file_, nullptr)
         << "Md5 file open failed. Filename: " << md5_file_name_;
   }
 
   virtual void DecompressedFrameHook(const vpx_image_t &img,
                                      const unsigned int frame_number) {
-    ASSERT_TRUE(md5_file_ != NULL);
+    ASSERT_NE(md5_file_, nullptr);
     char expected_md5[33];
     char junk[128];
 
@@ -286,24 +286,25 @@
 // Class for testing passing in external frame buffers to libvpx.
 class ExternalFrameBufferTest : public ::testing::Test {
  protected:
-  ExternalFrameBufferTest() : video_(NULL), decoder_(NULL), num_buffers_(0) {}
+  ExternalFrameBufferTest()
+      : video_(nullptr), decoder_(nullptr), num_buffers_(0) {}
 
   virtual void SetUp() {
     video_ = new libvpx_test::WebMVideoSource(kVP9TestFile);
-    ASSERT_TRUE(video_ != NULL);
+    ASSERT_NE(video_, nullptr);
     video_->Init();
     video_->Begin();
 
     vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
     decoder_ = new libvpx_test::VP9Decoder(cfg, 0);
-    ASSERT_TRUE(decoder_ != NULL);
+    ASSERT_NE(decoder_, nullptr);
   }
 
   virtual void TearDown() {
     delete decoder_;
-    decoder_ = NULL;
+    decoder_ = nullptr;
     delete video_;
-    video_ = NULL;
+    video_ = nullptr;
   }
 
   // Passes the external frame buffer information to libvpx.
@@ -327,7 +328,7 @@
   }
 
   vpx_codec_err_t DecodeRemainingFrames() {
-    for (; video_->cxdata() != NULL; video_->Next()) {
+    for (; video_->cxdata() != nullptr; video_->Next()) {
       const vpx_codec_err_t res =
           decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
       if (res != VPX_CODEC_OK) return res;
@@ -338,10 +339,10 @@
 
   void CheckDecodedFrames() {
     libvpx_test::DxDataIterator dec_iter = decoder_->GetDxData();
-    const vpx_image_t *img = NULL;
+    const vpx_image_t *img = nullptr;
 
     // Get decompressed data
-    while ((img = dec_iter.Next()) != NULL) {
+    while ((img = dec_iter.Next()) != nullptr) {
       fb_list_.CheckImageFrameBuffer(img);
     }
   }
@@ -356,13 +357,13 @@
  protected:
   virtual void SetUp() {
     video_ = new libvpx_test::WebMVideoSource(kVP9NonRefTestFile);
-    ASSERT_TRUE(video_ != NULL);
+    ASSERT_NE(video_, nullptr);
     video_->Init();
     video_->Begin();
 
     vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
     decoder_ = new libvpx_test::VP9Decoder(cfg, 0);
-    ASSERT_TRUE(decoder_ != NULL);
+    ASSERT_NE(decoder_, nullptr);
   }
 
   virtual void CheckFrameBufferRelease() {
@@ -405,7 +406,7 @@
     return;
 #endif
   }
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
   video->Init();
 
   // Construct md5 file name.
@@ -482,13 +483,14 @@
   const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS;
   ASSERT_EQ(
       VPX_CODEC_INVALID_PARAM,
-      SetFrameBufferFunctions(num_buffers, NULL, release_vp9_frame_buffer));
+      SetFrameBufferFunctions(num_buffers, nullptr, release_vp9_frame_buffer));
 }
 
 TEST_F(ExternalFrameBufferTest, NullReleaseFunction) {
   const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS;
-  ASSERT_EQ(VPX_CODEC_INVALID_PARAM,
-            SetFrameBufferFunctions(num_buffers, get_vp9_frame_buffer, NULL));
+  ASSERT_EQ(
+      VPX_CODEC_INVALID_PARAM,
+      SetFrameBufferFunctions(num_buffers, get_vp9_frame_buffer, nullptr));
 }
 
 TEST_F(ExternalFrameBufferTest, SetAfterDecode) {
--- a/test/frame_size_tests.cc
+++ b/test/frame_size_tests.cc
@@ -69,7 +69,7 @@
 #if CONFIG_VP9_ENCODER
     return &vpx_codec_vp9_cx_algo;
 #else
-    return NULL;
+    return nullptr;
 #endif
   }
 };
@@ -130,7 +130,7 @@
       encoder->InitEncoder(video);
       ASSERT_FALSE(::testing::Test::HasFatalFailure());
       for (bool again = true; again; video->Next()) {
-        again = (video->img() != NULL);
+        again = (video->img() != nullptr);
 
         PreEncodeFrameHook(video, encoder.get());
         encoder->EncodeFrame(video, frame_flags_, expected_err);
--- a/test/idct_test.cc
+++ b/test/idct_test.cc
@@ -31,13 +31,13 @@
     UUT = GetParam();
 
     input = new Buffer<int16_t>(4, 4, 0);
-    ASSERT_TRUE(input != NULL);
+    ASSERT_NE(input, nullptr);
     ASSERT_TRUE(input->Init());
     predict = new Buffer<uint8_t>(4, 4, 3);
-    ASSERT_TRUE(predict != NULL);
+    ASSERT_NE(predict, nullptr);
     ASSERT_TRUE(predict->Init());
     output = new Buffer<uint8_t>(4, 4, 3);
-    ASSERT_TRUE(output != NULL);
+    ASSERT_NE(output, nullptr);
     ASSERT_TRUE(output->Init());
   }
 
@@ -72,7 +72,7 @@
 
 TEST_P(IDCTTest, TestAllOnes) {
   input->Set(0);
-  ASSERT_TRUE(input->TopLeftPixel() != NULL);
+  ASSERT_NE(input->TopLeftPixel(), nullptr);
   // When the first element is '4' it will fill the output buffer with '1'.
   input->TopLeftPixel()[0] = 4;
   predict->Set(0);
@@ -90,7 +90,7 @@
   // Set the transform output to '1' and make sure it gets added to the
   // prediction buffer.
   input->Set(0);
-  ASSERT_TRUE(input->TopLeftPixel() != NULL);
+  ASSERT_NE(input->TopLeftPixel(), nullptr);
   input->TopLeftPixel()[0] = 4;
   output->Set(0);
 
--- a/test/invalid_file_test.cc
+++ b/test/invalid_file_test.cc
@@ -38,15 +38,15 @@
 class InvalidFileTest : public ::libvpx_test::DecoderTest,
                         public ::libvpx_test::CodecTestWithParam<DecodeParam> {
  protected:
-  InvalidFileTest() : DecoderTest(GET_PARAM(0)), res_file_(NULL) {}
+  InvalidFileTest() : DecoderTest(GET_PARAM(0)), res_file_(nullptr) {}
 
   virtual ~InvalidFileTest() {
-    if (res_file_ != NULL) fclose(res_file_);
+    if (res_file_ != nullptr) fclose(res_file_);
   }
 
   void OpenResFile(const std::string &res_file_name_) {
     res_file_ = libvpx_test::OpenTestDataFile(res_file_name_);
-    ASSERT_TRUE(res_file_ != NULL)
+    ASSERT_NE(res_file_, nullptr)
         << "Result file open failed. Filename: " << res_file_name_;
   }
 
@@ -54,7 +54,7 @@
       const vpx_codec_err_t res_dec,
       const libvpx_test::CompressedVideoSource &video,
       libvpx_test::Decoder *decoder) {
-    EXPECT_TRUE(res_file_ != NULL);
+    EXPECT_NE(res_file_, nullptr);
     int expected_res_dec;
 
     // Read integer result.
@@ -102,7 +102,7 @@
       return;
 #endif
     }
-    ASSERT_TRUE(video.get() != NULL);
+    ASSERT_NE(video.get(), nullptr);
     video->Init();
 
     // Construct result file name. The file holds a list of expected integer
--- a/test/non_greedy_mv_test.cc
+++ b/test/non_greedy_mv_test.cc
@@ -129,11 +129,11 @@
   const char *ground_truth_file =
       "non_greedy_mv_test_files/ground_truth_16x16.txt";
   BLOCK_SIZE bsize = BLOCK_32X32;
-  MV *search_mf = NULL;
-  MV *smooth_mf = NULL;
-  MV *estimation = NULL;
-  MV *ground_truth = NULL;
-  int(*local_var)[MF_LOCAL_STRUCTURE_SIZE] = NULL;
+  MV *search_mf = nullptr;
+  MV *smooth_mf = nullptr;
+  MV *estimation = nullptr;
+  MV *ground_truth = nullptr;
+  int(*local_var)[MF_LOCAL_STRUCTURE_SIZE] = nullptr;
   int rows = 0, cols = 0;
 
   int alpha = 100, max_iter = 100;
@@ -169,8 +169,8 @@
   const char *gt_local_var_file = "non_greedy_mv_test_files/localVar_16x16.txt";
   const char *search_mf_file = "non_greedy_mv_test_files/exhaust_16x16.txt";
   BLOCK_SIZE bsize = BLOCK_16X16;
-  int(*gt_local_var)[MF_LOCAL_STRUCTURE_SIZE] = NULL;
-  int(*est_local_var)[MF_LOCAL_STRUCTURE_SIZE] = NULL;
+  int(*gt_local_var)[MF_LOCAL_STRUCTURE_SIZE] = nullptr;
+  int(*est_local_var)[MF_LOCAL_STRUCTURE_SIZE] = nullptr;
   YV12_BUFFER_CONFIG ref_frame, cur_frame;
   int rows, cols;
   MV *search_mf;
--- a/test/partial_idct_test.cc
+++ b/test/partial_idct_test.cc
@@ -102,11 +102,11 @@
 
   virtual void TearDown() {
     vpx_free(input_block_);
-    input_block_ = NULL;
+    input_block_ = nullptr;
     vpx_free(output_block_);
-    output_block_ = NULL;
+    output_block_ = nullptr;
     vpx_free(output_block_ref_);
-    output_block_ref_ = NULL;
+    output_block_ref_ = nullptr;
     libvpx_test::ClearSystemState();
   }
 
--- a/test/pp_filter_test.cc
+++ b/test/pp_filter_test.cc
@@ -459,7 +459,7 @@
   SetRows(src_c_.TopLeftPixel(), rows_, cols_, src_c_.stride());
 
   unsigned char *expected_output = new unsigned char[rows_ * cols_];
-  ASSERT_TRUE(expected_output != NULL);
+  ASSERT_NE(expected_output, nullptr);
   SetRows(expected_output, rows_, cols_, cols_);
 
   RunFilterLevel(src_c_.TopLeftPixel(), rows_, cols_, src_c_.stride(), q2mbl(0),
--- a/test/predict_test.cc
+++ b/test/predict_test.cc
@@ -41,11 +41,11 @@
  public:
   PredictTestBase()
       : width_(GET_PARAM(0)), height_(GET_PARAM(1)), predict_(GET_PARAM(2)),
-        src_(NULL), padded_dst_(NULL), dst_(NULL), dst_c_(NULL) {}
+        src_(nullptr), padded_dst_(nullptr), dst_(nullptr), dst_c_(nullptr) {}
 
   virtual void SetUp() {
     src_ = new uint8_t[kSrcSize];
-    ASSERT_TRUE(src_ != NULL);
+    ASSERT_NE(src_, nullptr);
 
     // padded_dst_ provides a buffer of kBorderSize around the destination
     // memory to facilitate detecting out of bounds writes.
@@ -53,11 +53,11 @@
     padded_dst_size_ = dst_stride_ * (kBorderSize + height_ + kBorderSize);
     padded_dst_ =
         reinterpret_cast<uint8_t *>(vpx_memalign(16, padded_dst_size_));
-    ASSERT_TRUE(padded_dst_ != NULL);
+    ASSERT_NE(padded_dst_, nullptr);
     dst_ = padded_dst_ + (kBorderSize * dst_stride_) + kBorderSize;
 
     dst_c_ = new uint8_t[16 * 16];
-    ASSERT_TRUE(dst_c_ != NULL);
+    ASSERT_NE(dst_c_, nullptr);
 
     memset(src_, 0, kSrcSize);
     memset(padded_dst_, 128, padded_dst_size_);
@@ -66,12 +66,12 @@
 
   virtual void TearDown() {
     delete[] src_;
-    src_ = NULL;
+    src_ = nullptr;
     vpx_free(padded_dst_);
-    padded_dst_ = NULL;
-    dst_ = NULL;
+    padded_dst_ = nullptr;
+    dst_ = nullptr;
     delete[] dst_c_;
-    dst_c_ = NULL;
+    dst_c_ = nullptr;
     libvpx_test::ClearSystemState();
   }
 
--- a/test/quantize_test.cc
+++ b/test/quantize_test.cc
@@ -46,9 +46,9 @@
  public:
   virtual ~QuantizeTestBase() {
     vp8_remove_compressor(&vp8_comp_);
-    vp8_comp_ = NULL;
+    vp8_comp_ = nullptr;
     vpx_free(macroblockd_dst_);
-    macroblockd_dst_ = NULL;
+    macroblockd_dst_ = nullptr;
     libvpx_test::ClearSystemState();
   }
 
--- a/test/resize_test.cc
+++ b/test/resize_test.cc
@@ -350,7 +350,7 @@
  protected:
 #if WRITE_COMPRESSED_STREAM
   ResizeInternalTest()
-      : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
+      : ResizeTest(), frame0_psnr_(0.0), outfile_(nullptr), out_frames_(0) {}
 #else
   ResizeInternalTest() : ResizeTest(), frame0_psnr_(0.0) {}
 #endif
@@ -369,7 +369,7 @@
       if (!fseek(outfile_, 0, SEEK_SET))
         write_ivf_file_header(&cfg_, out_frames_, outfile_);
       fclose(outfile_);
-      outfile_ = NULL;
+      outfile_ = nullptr;
     }
 #endif
   }
@@ -705,7 +705,7 @@
  protected:
 #if WRITE_COMPRESSED_STREAM
   ResizeCspTest()
-      : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
+      : ResizeTest(), frame0_psnr_(0.0), outfile_(nullptr), out_frames_(0) {}
 #else
   ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {}
 #endif
@@ -724,7 +724,7 @@
       if (!fseek(outfile_, 0, SEEK_SET))
         write_ivf_file_header(&cfg_, out_frames_, outfile_);
       fclose(outfile_);
-      outfile_ = NULL;
+      outfile_ = nullptr;
     }
 #endif
   }
--- a/test/sad_test.cc
+++ b/test/sad_test.cc
@@ -99,17 +99,17 @@
 
   virtual void TearDown() {
     vpx_free(source_data8_);
-    source_data8_ = NULL;
+    source_data8_ = nullptr;
     vpx_free(reference_data8_);
-    reference_data8_ = NULL;
+    reference_data8_ = nullptr;
     vpx_free(second_pred8_);
-    second_pred8_ = NULL;
+    second_pred8_ = nullptr;
     vpx_free(source_data16_);
-    source_data16_ = NULL;
+    source_data16_ = nullptr;
     vpx_free(reference_data16_);
-    reference_data16_ = NULL;
+    reference_data16_ = nullptr;
     vpx_free(second_pred16_);
-    second_pred16_ = NULL;
+    second_pred16_ = nullptr;
 
     libvpx_test::ClearSystemState();
   }
--- a/test/superframe_test.cc
+++ b/test/superframe_test.cc
@@ -27,7 +27,7 @@
       public ::libvpx_test::CodecTestWithParam<SuperframeTestParam> {
  protected:
   SuperframeTest()
-      : EncoderTest(GET_PARAM(0)), modified_buf_(NULL), last_sf_pts_(0) {}
+      : EncoderTest(GET_PARAM(0)), modified_buf_(nullptr), last_sf_pts_(0) {}
   virtual ~SuperframeTest() {}
 
   virtual void SetUp() {
--- a/test/test_intra_pred_speed.cc
+++ b/test/test_intra_pred_speed.cc
@@ -85,7 +85,7 @@
   intra_pred_test_mem.Init(block_size, 8);
 
   for (int k = 0; k < kNumVp9IntraPredFuncs; ++k) {
-    if (pred_funcs[k] == NULL) continue;
+    if (pred_funcs[k] == nullptr) continue;
     memcpy(intra_pred_test_mem.src, intra_pred_test_mem.ref_src,
            sizeof(intra_pred_test_mem.src));
     vpx_usec_timer timer;
@@ -206,58 +206,64 @@
 INTRA_PRED_TEST(SSE2, TestIntraPred4, vpx_dc_predictor_4x4_sse2,
                 vpx_dc_left_predictor_4x4_sse2, vpx_dc_top_predictor_4x4_sse2,
                 vpx_dc_128_predictor_4x4_sse2, vpx_v_predictor_4x4_sse2,
-                vpx_h_predictor_4x4_sse2, vpx_d45_predictor_4x4_sse2, NULL,
-                NULL, NULL, vpx_d207_predictor_4x4_sse2, NULL,
+                vpx_h_predictor_4x4_sse2, vpx_d45_predictor_4x4_sse2, nullptr,
+                nullptr, nullptr, vpx_d207_predictor_4x4_sse2, nullptr,
                 vpx_tm_predictor_4x4_sse2)
 
 INTRA_PRED_TEST(SSE2, TestIntraPred8, vpx_dc_predictor_8x8_sse2,
                 vpx_dc_left_predictor_8x8_sse2, vpx_dc_top_predictor_8x8_sse2,
                 vpx_dc_128_predictor_8x8_sse2, vpx_v_predictor_8x8_sse2,
-                vpx_h_predictor_8x8_sse2, vpx_d45_predictor_8x8_sse2, NULL,
-                NULL, NULL, NULL, NULL, vpx_tm_predictor_8x8_sse2)
+                vpx_h_predictor_8x8_sse2, vpx_d45_predictor_8x8_sse2, nullptr,
+                nullptr, nullptr, nullptr, nullptr, vpx_tm_predictor_8x8_sse2)
 
 INTRA_PRED_TEST(SSE2, TestIntraPred16, vpx_dc_predictor_16x16_sse2,
                 vpx_dc_left_predictor_16x16_sse2,
                 vpx_dc_top_predictor_16x16_sse2,
                 vpx_dc_128_predictor_16x16_sse2, vpx_v_predictor_16x16_sse2,
-                vpx_h_predictor_16x16_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_16x16_sse2)
+                vpx_h_predictor_16x16_sse2, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_tm_predictor_16x16_sse2)
 
 INTRA_PRED_TEST(SSE2, TestIntraPred32, vpx_dc_predictor_32x32_sse2,
                 vpx_dc_left_predictor_32x32_sse2,
                 vpx_dc_top_predictor_32x32_sse2,
                 vpx_dc_128_predictor_32x32_sse2, vpx_v_predictor_32x32_sse2,
-                vpx_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_32x32_sse2)
+                vpx_h_predictor_32x32_sse2, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_tm_predictor_32x32_sse2)
 #endif  // HAVE_SSE2
 
 #if HAVE_SSSE3
-INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, vpx_d153_predictor_4x4_ssse3, NULL,
-                vpx_d63_predictor_4x4_ssse3, NULL)
-INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, vpx_d153_predictor_8x8_ssse3,
-                vpx_d207_predictor_8x8_ssse3, vpx_d63_predictor_8x8_ssse3, NULL)
-INTRA_PRED_TEST(SSSE3, TestIntraPred16, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_d45_predictor_16x16_ssse3, NULL, NULL,
-                vpx_d153_predictor_16x16_ssse3, vpx_d207_predictor_16x16_ssse3,
-                vpx_d63_predictor_16x16_ssse3, NULL)
-INTRA_PRED_TEST(SSSE3, TestIntraPred32, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_d45_predictor_32x32_ssse3, NULL, NULL,
-                vpx_d153_predictor_32x32_ssse3, vpx_d207_predictor_32x32_ssse3,
-                vpx_d63_predictor_32x32_ssse3, NULL)
+INTRA_PRED_TEST(SSSE3, TestIntraPred4, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, nullptr, nullptr, nullptr,
+                vpx_d153_predictor_4x4_ssse3, nullptr,
+                vpx_d63_predictor_4x4_ssse3, nullptr)
+INTRA_PRED_TEST(SSSE3, TestIntraPred8, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, nullptr, nullptr, nullptr,
+                vpx_d153_predictor_8x8_ssse3, vpx_d207_predictor_8x8_ssse3,
+                vpx_d63_predictor_8x8_ssse3, nullptr)
+INTRA_PRED_TEST(SSSE3, TestIntraPred16, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_d45_predictor_16x16_ssse3, nullptr,
+                nullptr, vpx_d153_predictor_16x16_ssse3,
+                vpx_d207_predictor_16x16_ssse3, vpx_d63_predictor_16x16_ssse3,
+                nullptr)
+INTRA_PRED_TEST(SSSE3, TestIntraPred32, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_d45_predictor_32x32_ssse3, nullptr,
+                nullptr, vpx_d153_predictor_32x32_ssse3,
+                vpx_d207_predictor_32x32_ssse3, vpx_d63_predictor_32x32_ssse3,
+                nullptr)
 #endif  // HAVE_SSSE3
 
 #if HAVE_DSPR2
-INTRA_PRED_TEST(DSPR2, TestIntraPred4, vpx_dc_predictor_4x4_dspr2, NULL, NULL,
-                NULL, NULL, vpx_h_predictor_4x4_dspr2, NULL, NULL, NULL, NULL,
-                NULL, NULL, vpx_tm_predictor_4x4_dspr2)
-INTRA_PRED_TEST(DSPR2, TestIntraPred8, vpx_dc_predictor_8x8_dspr2, NULL, NULL,
-                NULL, NULL, vpx_h_predictor_8x8_dspr2, NULL, NULL, NULL, NULL,
-                NULL, NULL, vpx_tm_predictor_8x8_c)
-INTRA_PRED_TEST(DSPR2, TestIntraPred16, vpx_dc_predictor_16x16_dspr2, NULL,
-                NULL, NULL, NULL, vpx_h_predictor_16x16_dspr2, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL)
+INTRA_PRED_TEST(DSPR2, TestIntraPred4, vpx_dc_predictor_4x4_dspr2, nullptr,
+                nullptr, nullptr, nullptr, vpx_h_predictor_4x4_dspr2, nullptr,
+                nullptr, nullptr, nullptr, nullptr, nullptr,
+                vpx_tm_predictor_4x4_dspr2)
+INTRA_PRED_TEST(DSPR2, TestIntraPred8, vpx_dc_predictor_8x8_dspr2, nullptr,
+                nullptr, nullptr, nullptr, vpx_h_predictor_8x8_dspr2, nullptr,
+                nullptr, nullptr, nullptr, nullptr, nullptr,
+                vpx_tm_predictor_8x8_c)
+INTRA_PRED_TEST(DSPR2, TestIntraPred16, vpx_dc_predictor_16x16_dspr2, nullptr,
+                nullptr, nullptr, nullptr, vpx_h_predictor_16x16_dspr2, nullptr,
+                nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)
 #endif  // HAVE_DSPR2
 
 #if HAVE_NEON
@@ -265,13 +271,13 @@
                 vpx_dc_left_predictor_4x4_neon, vpx_dc_top_predictor_4x4_neon,
                 vpx_dc_128_predictor_4x4_neon, vpx_v_predictor_4x4_neon,
                 vpx_h_predictor_4x4_neon, vpx_d45_predictor_4x4_neon,
-                vpx_d135_predictor_4x4_neon, NULL, NULL, NULL, NULL,
+                vpx_d135_predictor_4x4_neon, nullptr, nullptr, nullptr, nullptr,
                 vpx_tm_predictor_4x4_neon)
 INTRA_PRED_TEST(NEON, TestIntraPred8, vpx_dc_predictor_8x8_neon,
                 vpx_dc_left_predictor_8x8_neon, vpx_dc_top_predictor_8x8_neon,
                 vpx_dc_128_predictor_8x8_neon, vpx_v_predictor_8x8_neon,
                 vpx_h_predictor_8x8_neon, vpx_d45_predictor_8x8_neon,
-                vpx_d135_predictor_8x8_neon, NULL, NULL, NULL, NULL,
+                vpx_d135_predictor_8x8_neon, nullptr, nullptr, nullptr, nullptr,
                 vpx_tm_predictor_8x8_neon)
 INTRA_PRED_TEST(NEON, TestIntraPred16, vpx_dc_predictor_16x16_neon,
                 vpx_dc_left_predictor_16x16_neon,
@@ -278,15 +284,15 @@
                 vpx_dc_top_predictor_16x16_neon,
                 vpx_dc_128_predictor_16x16_neon, vpx_v_predictor_16x16_neon,
                 vpx_h_predictor_16x16_neon, vpx_d45_predictor_16x16_neon,
-                vpx_d135_predictor_16x16_neon, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_16x16_neon)
+                vpx_d135_predictor_16x16_neon, nullptr, nullptr, nullptr,
+                nullptr, vpx_tm_predictor_16x16_neon)
 INTRA_PRED_TEST(NEON, TestIntraPred32, vpx_dc_predictor_32x32_neon,
                 vpx_dc_left_predictor_32x32_neon,
                 vpx_dc_top_predictor_32x32_neon,
                 vpx_dc_128_predictor_32x32_neon, vpx_v_predictor_32x32_neon,
                 vpx_h_predictor_32x32_neon, vpx_d45_predictor_32x32_neon,
-                vpx_d135_predictor_32x32_neon, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_32x32_neon)
+                vpx_d135_predictor_32x32_neon, nullptr, nullptr, nullptr,
+                nullptr, vpx_tm_predictor_32x32_neon)
 #endif  // HAVE_NEON
 
 #if HAVE_MSA
@@ -293,50 +299,50 @@
 INTRA_PRED_TEST(MSA, TestIntraPred4, vpx_dc_predictor_4x4_msa,
                 vpx_dc_left_predictor_4x4_msa, vpx_dc_top_predictor_4x4_msa,
                 vpx_dc_128_predictor_4x4_msa, vpx_v_predictor_4x4_msa,
-                vpx_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_4x4_msa)
+                vpx_h_predictor_4x4_msa, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_tm_predictor_4x4_msa)
 INTRA_PRED_TEST(MSA, TestIntraPred8, vpx_dc_predictor_8x8_msa,
                 vpx_dc_left_predictor_8x8_msa, vpx_dc_top_predictor_8x8_msa,
                 vpx_dc_128_predictor_8x8_msa, vpx_v_predictor_8x8_msa,
-                vpx_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_8x8_msa)
+                vpx_h_predictor_8x8_msa, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_tm_predictor_8x8_msa)
 INTRA_PRED_TEST(MSA, TestIntraPred16, vpx_dc_predictor_16x16_msa,
                 vpx_dc_left_predictor_16x16_msa, vpx_dc_top_predictor_16x16_msa,
                 vpx_dc_128_predictor_16x16_msa, vpx_v_predictor_16x16_msa,
-                vpx_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_16x16_msa)
+                vpx_h_predictor_16x16_msa, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_tm_predictor_16x16_msa)
 INTRA_PRED_TEST(MSA, TestIntraPred32, vpx_dc_predictor_32x32_msa,
                 vpx_dc_left_predictor_32x32_msa, vpx_dc_top_predictor_32x32_msa,
                 vpx_dc_128_predictor_32x32_msa, vpx_v_predictor_32x32_msa,
-                vpx_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_32x32_msa)
+                vpx_h_predictor_32x32_msa, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, vpx_tm_predictor_32x32_msa)
 #endif  // HAVE_MSA
 
 #if HAVE_VSX
 // TODO(crbug.com/webm/1522): Fix test failures.
 #if 0
-INTRA_PRED_TEST(VSX, TestIntraPred4, NULL, NULL, NULL, NULL, NULL,
-                vpx_h_predictor_4x4_vsx, NULL, NULL, NULL, NULL, NULL, NULL,
-                vpx_tm_predictor_4x4_vsx)
+INTRA_PRED_TEST(VSX, TestIntraPred4, nullptr, nullptr, nullptr, nullptr,
+                nullptr, vpx_h_predictor_4x4_vsx, nullptr, nullptr, nullptr,
+                nullptr, nullptr, nullptr, vpx_tm_predictor_4x4_vsx)
 
-INTRA_PRED_TEST(VSX, TestIntraPred8, vpx_dc_predictor_8x8_vsx, NULL, NULL, NULL,
-                NULL, vpx_h_predictor_8x8_vsx, vpx_d45_predictor_8x8_vsx, NULL,
-                NULL, NULL, NULL, vpx_d63_predictor_8x8_vsx,
-                vpx_tm_predictor_8x8_vsx)
+INTRA_PRED_TEST(VSX, TestIntraPred8, vpx_dc_predictor_8x8_vsx, nullptr, nullptr,
+                nullptr, nullptr, vpx_h_predictor_8x8_vsx,
+                vpx_d45_predictor_8x8_vsx, nullptr, nullptr, nullptr, nullptr,
+                vpx_d63_predictor_8x8_vsx, vpx_tm_predictor_8x8_vsx)
 #endif
 
 INTRA_PRED_TEST(VSX, TestIntraPred16, vpx_dc_predictor_16x16_vsx,
                 vpx_dc_left_predictor_16x16_vsx, vpx_dc_top_predictor_16x16_vsx,
                 vpx_dc_128_predictor_16x16_vsx, vpx_v_predictor_16x16_vsx,
-                vpx_h_predictor_16x16_vsx, vpx_d45_predictor_16x16_vsx, NULL,
-                NULL, NULL, NULL, vpx_d63_predictor_16x16_vsx,
+                vpx_h_predictor_16x16_vsx, vpx_d45_predictor_16x16_vsx, nullptr,
+                nullptr, nullptr, nullptr, vpx_d63_predictor_16x16_vsx,
                 vpx_tm_predictor_16x16_vsx)
 
 INTRA_PRED_TEST(VSX, TestIntraPred32, vpx_dc_predictor_32x32_vsx,
                 vpx_dc_left_predictor_32x32_vsx, vpx_dc_top_predictor_32x32_vsx,
                 vpx_dc_128_predictor_32x32_vsx, vpx_v_predictor_32x32_vsx,
-                vpx_h_predictor_32x32_vsx, vpx_d45_predictor_32x32_vsx, NULL,
-                NULL, NULL, NULL, vpx_d63_predictor_32x32_vsx,
+                vpx_h_predictor_32x32_vsx, vpx_d45_predictor_32x32_vsx, nullptr,
+                nullptr, nullptr, nullptr, vpx_d63_predictor_32x32_vsx,
                 vpx_tm_predictor_32x32_vsx)
 #endif  // HAVE_VSX
 
@@ -361,7 +367,7 @@
   intra_pred_test_mem.Init(block_size, 12);
 
   for (int k = 0; k < kNumVp9IntraPredFuncs; ++k) {
-    if (pred_funcs[k] == NULL) continue;
+    if (pred_funcs[k] == nullptr) continue;
     memcpy(intra_pred_test_mem.src, intra_pred_test_mem.ref_src,
            sizeof(intra_pred_test_mem.src));
     vpx_usec_timer timer;
@@ -487,19 +493,17 @@
     SSE2, TestHighbdIntraPred4, vpx_highbd_dc_predictor_4x4_sse2,
     vpx_highbd_dc_left_predictor_4x4_sse2, vpx_highbd_dc_top_predictor_4x4_sse2,
     vpx_highbd_dc_128_predictor_4x4_sse2, vpx_highbd_v_predictor_4x4_sse2,
-    vpx_highbd_h_predictor_4x4_sse2, NULL, vpx_highbd_d135_predictor_4x4_sse2,
-    vpx_highbd_d117_predictor_4x4_sse2, vpx_highbd_d153_predictor_4x4_sse2,
-    vpx_highbd_d207_predictor_4x4_sse2, vpx_highbd_d63_predictor_4x4_sse2,
-    vpx_highbd_tm_predictor_4x4_c)
+    vpx_highbd_h_predictor_4x4_sse2, nullptr,
+    vpx_highbd_d135_predictor_4x4_sse2, vpx_highbd_d117_predictor_4x4_sse2,
+    vpx_highbd_d153_predictor_4x4_sse2, vpx_highbd_d207_predictor_4x4_sse2,
+    vpx_highbd_d63_predictor_4x4_sse2, vpx_highbd_tm_predictor_4x4_c)
 
-HIGHBD_INTRA_PRED_TEST(SSE2, TestHighbdIntraPred8,
-                       vpx_highbd_dc_predictor_8x8_sse2,
-                       vpx_highbd_dc_left_predictor_8x8_sse2,
-                       vpx_highbd_dc_top_predictor_8x8_sse2,
-                       vpx_highbd_dc_128_predictor_8x8_sse2,
-                       vpx_highbd_v_predictor_8x8_sse2,
-                       vpx_highbd_h_predictor_8x8_sse2, NULL, NULL, NULL, NULL,
-                       NULL, NULL, vpx_highbd_tm_predictor_8x8_sse2)
+HIGHBD_INTRA_PRED_TEST(
+    SSE2, TestHighbdIntraPred8, vpx_highbd_dc_predictor_8x8_sse2,
+    vpx_highbd_dc_left_predictor_8x8_sse2, vpx_highbd_dc_top_predictor_8x8_sse2,
+    vpx_highbd_dc_128_predictor_8x8_sse2, vpx_highbd_v_predictor_8x8_sse2,
+    vpx_highbd_h_predictor_8x8_sse2, nullptr, nullptr, nullptr, nullptr,
+    nullptr, nullptr, vpx_highbd_tm_predictor_8x8_sse2)
 
 HIGHBD_INTRA_PRED_TEST(SSE2, TestHighbdIntraPred16,
                        vpx_highbd_dc_predictor_16x16_sse2,
@@ -507,8 +511,9 @@
                        vpx_highbd_dc_top_predictor_16x16_sse2,
                        vpx_highbd_dc_128_predictor_16x16_sse2,
                        vpx_highbd_v_predictor_16x16_sse2,
-                       vpx_highbd_h_predictor_16x16_sse2, NULL, NULL, NULL,
-                       NULL, NULL, NULL, vpx_highbd_tm_predictor_16x16_sse2)
+                       vpx_highbd_h_predictor_16x16_sse2, nullptr, nullptr,
+                       nullptr, nullptr, nullptr, nullptr,
+                       vpx_highbd_tm_predictor_16x16_sse2)
 
 HIGHBD_INTRA_PRED_TEST(SSE2, TestHighbdIntraPred32,
                        vpx_highbd_dc_predictor_32x32_sse2,
@@ -516,35 +521,40 @@
                        vpx_highbd_dc_top_predictor_32x32_sse2,
                        vpx_highbd_dc_128_predictor_32x32_sse2,
                        vpx_highbd_v_predictor_32x32_sse2,
-                       vpx_highbd_h_predictor_32x32_sse2, NULL, NULL, NULL,
-                       NULL, NULL, NULL, vpx_highbd_tm_predictor_32x32_sse2)
+                       vpx_highbd_h_predictor_32x32_sse2, nullptr, nullptr,
+                       nullptr, nullptr, nullptr, nullptr,
+                       vpx_highbd_tm_predictor_32x32_sse2)
 #endif  // HAVE_SSE2
 
 #if HAVE_SSSE3
-HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred4, NULL, NULL, NULL, NULL,
-                       NULL, NULL, vpx_highbd_d45_predictor_4x4_ssse3, NULL,
-                       NULL, NULL, NULL, NULL, NULL)
-HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred8, NULL, NULL, NULL, NULL,
-                       NULL, NULL, vpx_highbd_d45_predictor_8x8_ssse3,
+HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred4, nullptr, nullptr, nullptr,
+                       nullptr, nullptr, nullptr,
+                       vpx_highbd_d45_predictor_4x4_ssse3, nullptr, nullptr,
+                       nullptr, nullptr, nullptr, nullptr)
+HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred8, nullptr, nullptr, nullptr,
+                       nullptr, nullptr, nullptr,
+                       vpx_highbd_d45_predictor_8x8_ssse3,
                        vpx_highbd_d135_predictor_8x8_ssse3,
                        vpx_highbd_d117_predictor_8x8_ssse3,
                        vpx_highbd_d153_predictor_8x8_ssse3,
                        vpx_highbd_d207_predictor_8x8_ssse3,
-                       vpx_highbd_d63_predictor_8x8_ssse3, NULL)
-HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred16, NULL, NULL, NULL, NULL,
-                       NULL, NULL, vpx_highbd_d45_predictor_16x16_ssse3,
+                       vpx_highbd_d63_predictor_8x8_ssse3, nullptr)
+HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred16, nullptr, nullptr, nullptr,
+                       nullptr, nullptr, nullptr,
+                       vpx_highbd_d45_predictor_16x16_ssse3,
                        vpx_highbd_d135_predictor_16x16_ssse3,
                        vpx_highbd_d117_predictor_16x16_ssse3,
                        vpx_highbd_d153_predictor_16x16_ssse3,
                        vpx_highbd_d207_predictor_16x16_ssse3,
-                       vpx_highbd_d63_predictor_16x16_ssse3, NULL)
-HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred32, NULL, NULL, NULL, NULL,
-                       NULL, NULL, vpx_highbd_d45_predictor_32x32_ssse3,
+                       vpx_highbd_d63_predictor_16x16_ssse3, nullptr)
+HIGHBD_INTRA_PRED_TEST(SSSE3, TestHighbdIntraPred32, nullptr, nullptr, nullptr,
+                       nullptr, nullptr, nullptr,
+                       vpx_highbd_d45_predictor_32x32_ssse3,
                        vpx_highbd_d135_predictor_32x32_ssse3,
                        vpx_highbd_d117_predictor_32x32_ssse3,
                        vpx_highbd_d153_predictor_32x32_ssse3,
                        vpx_highbd_d207_predictor_32x32_ssse3,
-                       vpx_highbd_d63_predictor_32x32_ssse3, NULL)
+                       vpx_highbd_d63_predictor_32x32_ssse3, nullptr)
 #endif  // HAVE_SSSE3
 
 #if HAVE_NEON
@@ -553,7 +563,7 @@
     vpx_highbd_dc_left_predictor_4x4_neon, vpx_highbd_dc_top_predictor_4x4_neon,
     vpx_highbd_dc_128_predictor_4x4_neon, vpx_highbd_v_predictor_4x4_neon,
     vpx_highbd_h_predictor_4x4_neon, vpx_highbd_d45_predictor_4x4_neon,
-    vpx_highbd_d135_predictor_4x4_neon, NULL, NULL, NULL, NULL,
+    vpx_highbd_d135_predictor_4x4_neon, nullptr, nullptr, nullptr, nullptr,
     vpx_highbd_tm_predictor_4x4_neon)
 HIGHBD_INTRA_PRED_TEST(
     NEON, TestHighbdIntraPred8, vpx_highbd_dc_predictor_8x8_neon,
@@ -560,7 +570,7 @@
     vpx_highbd_dc_left_predictor_8x8_neon, vpx_highbd_dc_top_predictor_8x8_neon,
     vpx_highbd_dc_128_predictor_8x8_neon, vpx_highbd_v_predictor_8x8_neon,
     vpx_highbd_h_predictor_8x8_neon, vpx_highbd_d45_predictor_8x8_neon,
-    vpx_highbd_d135_predictor_8x8_neon, NULL, NULL, NULL, NULL,
+    vpx_highbd_d135_predictor_8x8_neon, nullptr, nullptr, nullptr, nullptr,
     vpx_highbd_tm_predictor_8x8_neon)
 HIGHBD_INTRA_PRED_TEST(NEON, TestHighbdIntraPred16,
                        vpx_highbd_dc_predictor_16x16_neon,
@@ -570,8 +580,8 @@
                        vpx_highbd_v_predictor_16x16_neon,
                        vpx_highbd_h_predictor_16x16_neon,
                        vpx_highbd_d45_predictor_16x16_neon,
-                       vpx_highbd_d135_predictor_16x16_neon, NULL, NULL, NULL,
-                       NULL, vpx_highbd_tm_predictor_16x16_neon)
+                       vpx_highbd_d135_predictor_16x16_neon, nullptr, nullptr,
+                       nullptr, nullptr, vpx_highbd_tm_predictor_16x16_neon)
 HIGHBD_INTRA_PRED_TEST(NEON, TestHighbdIntraPred32,
                        vpx_highbd_dc_predictor_32x32_neon,
                        vpx_highbd_dc_left_predictor_32x32_neon,
@@ -580,8 +590,8 @@
                        vpx_highbd_v_predictor_32x32_neon,
                        vpx_highbd_h_predictor_32x32_neon,
                        vpx_highbd_d45_predictor_32x32_neon,
-                       vpx_highbd_d135_predictor_32x32_neon, NULL, NULL, NULL,
-                       NULL, vpx_highbd_tm_predictor_32x32_neon)
+                       vpx_highbd_d135_predictor_32x32_neon, nullptr, nullptr,
+                       nullptr, nullptr, vpx_highbd_tm_predictor_32x32_neon)
 #endif  // HAVE_NEON
 
 #endif  // CONFIG_VP9_HIGHBITDEPTH
--- a/test/test_vector_test.cc
+++ b/test/test_vector_test.cc
@@ -40,7 +40,7 @@
 class TestVectorTest : public ::libvpx_test::DecoderTest,
                        public ::libvpx_test::CodecTestWithParam<DecodeParam> {
  protected:
-  TestVectorTest() : DecoderTest(GET_PARAM(0)), md5_file_(NULL) {
+  TestVectorTest() : DecoderTest(GET_PARAM(0)), md5_file_(nullptr) {
 #if CONFIG_VP9_DECODER
     resize_clips_.insert(::libvpx_test::kVP9TestVectorsResize,
                          ::libvpx_test::kVP9TestVectorsResize +
@@ -54,7 +54,7 @@
 
   void OpenMD5File(const std::string &md5_file_name_) {
     md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_);
-    ASSERT_TRUE(md5_file_ != NULL)
+    ASSERT_NE(md5_file_, nullptr)
         << "Md5 file open failed. Filename: " << md5_file_name_;
   }
 
@@ -79,7 +79,7 @@
 
   virtual void DecompressedFrameHook(const vpx_image_t &img,
                                      const unsigned int frame_number) {
-    ASSERT_TRUE(md5_file_ != NULL);
+    ASSERT_NE(md5_file_, nullptr);
     char expected_md5[33];
     char junk[128];
 
@@ -137,7 +137,7 @@
     return;
 #endif
   }
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
   video->Init();
 
   // Construct md5 file name.
--- a/test/user_priv_test.cc
+++ b/test/user_priv_test.cc
@@ -57,18 +57,18 @@
     void *user_priv = reinterpret_cast<void *>(&frame_num);
     const vpx_codec_err_t res =
         decoder.DecodeFrame(video.cxdata(), video.frame_size(),
-                            (frame_num == 0) ? NULL : user_priv);
+                            (frame_num == 0) ? nullptr : user_priv);
     if (res != VPX_CODEC_OK) {
       EXPECT_EQ(VPX_CODEC_OK, res) << decoder.DecodeError();
       break;
     }
     libvpx_test::DxDataIterator dec_iter = decoder.GetDxData();
-    const vpx_image_t *img = NULL;
+    const vpx_image_t *img = nullptr;
 
     // Get decompressed data.
     while ((img = dec_iter.Next())) {
       if (frame_num == 0) {
-        CheckUserPrivateData(img->user_priv, NULL);
+        CheckUserPrivateData(img->user_priv, nullptr);
       } else {
         CheckUserPrivateData(img->user_priv, &frame_num);
 
@@ -78,7 +78,7 @@
         ref.idx = rnd.Rand8() % 3;
         decoder.Control(VP9_GET_REFERENCE, &ref);
 
-        CheckUserPrivateData(ref.img.user_priv, NULL);
+        CheckUserPrivateData(ref.img.user_priv, nullptr);
       }
       md5.Add(img);
     }
--- a/test/variance_test.cc
+++ b/test/variance_test.cc
@@ -253,7 +253,7 @@
 
 template <typename Func>
 struct TestParams {
-  TestParams(int log2w = 0, int log2h = 0, Func function = NULL,
+  TestParams(int log2w = 0, int log2h = 0, Func function = nullptr,
              int bit_depth_value = 0)
       : log2width(log2w), log2height(log2h), func(function) {
     use_high_bit_depth = (bit_depth_value > 0);
@@ -297,8 +297,8 @@
         use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t);
     src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size() * unit));
     ref_ = new uint8_t[block_size() * unit];
-    ASSERT_TRUE(src_ != NULL);
-    ASSERT_TRUE(ref_ != NULL);
+    ASSERT_NE(src_, nullptr);
+    ASSERT_NE(ref_, nullptr);
 #if CONFIG_VP9_HIGHBITDEPTH
     if (use_high_bit_depth()) {
       // TODO(skal): remove!
@@ -319,8 +319,8 @@
 
     vpx_free(src_);
     delete[] ref_;
-    src_ = NULL;
-    ref_ = NULL;
+    src_ = nullptr;
+    ref_ = nullptr;
     libvpx_test::ClearSystemState();
   }
 
@@ -573,9 +573,9 @@
           (block_size() + width() + height() + 1) * sizeof(uint16_t))));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
     }
-    ASSERT_TRUE(src_ != NULL);
-    ASSERT_TRUE(sec_ != NULL);
-    ASSERT_TRUE(ref_ != NULL);
+    ASSERT_NE(src_, nullptr);
+    ASSERT_NE(sec_, nullptr);
+    ASSERT_NE(ref_, nullptr);
   }
 
   virtual void TearDown() {
--- a/test/vp9_boolcoder_test.cc
+++ b/test/vp9_boolcoder_test.cc
@@ -74,7 +74,7 @@
         GTEST_ASSERT_EQ(bw_buffer[0] & 0x80, 0);
 
         vpx_reader br;
-        vpx_reader_init(&br, bw_buffer, kBufferSize, NULL, NULL);
+        vpx_reader_init(&br, bw_buffer, kBufferSize, nullptr, nullptr);
         bit_rnd.Reset(random_seed);
         for (int i = 0; i < kBitsToTest; ++i) {
           if (bit_method == 2) {
--- a/test/vp9_datarate_test.cc
+++ b/test/vp9_datarate_test.cc
@@ -701,7 +701,7 @@
   // Use 2 states: 1 is center square, 0 is the rest.
   roi_.roi_map = reinterpret_cast<uint8_t *>(
       calloc(roi_.rows * roi_.cols, sizeof(*roi_.roi_map)));
-  ASSERT_TRUE(roi_.roi_map != NULL);
+  ASSERT_NE(roi_.roi_map, nullptr);
 
   for (unsigned int i = 0; i < roi_.rows; ++i) {
     for (unsigned int j = 0; j < roi_.cols; ++j) {
--- a/test/vp9_encoder_parms_get_to_decoder.cc
+++ b/test/vp9_encoder_parms_get_to_decoder.cc
@@ -142,7 +142,7 @@
 
   std::unique_ptr<libvpx_test::VideoSource> video(
       new libvpx_test::Y4mVideoSource(test_video_.name, 0, test_video_.frames));
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
 
   ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
 }
--- a/test/vp9_end_to_end_test.cc
+++ b/test/vp9_end_to_end_test.cc
@@ -257,7 +257,7 @@
   video.reset(new libvpx_test::YUVVideoSource(test_video_param_.filename,
                                               test_video_param_.fmt, 352, 288,
                                               30, 1, 0, 100));
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
 
   ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
 }
@@ -280,7 +280,7 @@
         test_video_param_.filename, test_video_param_.fmt, kWidth, kHeight,
         kFramerate, 1, 0, kFrames));
   }
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
 
   ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
   const double psnr = GetAveragePsnr();
@@ -307,7 +307,7 @@
         test_video_param_.filename, test_video_param_.fmt, kWidth, kHeight,
         kFramerate, 1, 0, kFrames));
   }
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
 
   ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
   const double psnr = GetAveragePsnr();
--- a/test/vp9_ethread_test.cc
+++ b/test/vp9_ethread_test.cc
@@ -41,7 +41,7 @@
 
     row_mt_mode_ = 1;
     first_pass_only_ = true;
-    firstpass_stats_.buf = NULL;
+    firstpass_stats_.buf = nullptr;
     firstpass_stats_.sz = 0;
   }
   virtual ~VPxFirstPassEncoderThreadTest() { free(firstpass_stats_.buf); }
--- a/test/vp9_intrapred_test.cc
+++ b/test/vp9_intrapred_test.cc
@@ -32,7 +32,7 @@
                               const uint8_t *above, const uint8_t *left);
 
 struct IntraPredParam {
-  IntraPredParam(IntraPredFunc pred = NULL, IntraPredFunc ref = NULL,
+  IntraPredParam(IntraPredFunc pred = nullptr, IntraPredFunc ref = nullptr,
                  int block_size_value = 0, int bit_depth_value = 0)
       : pred_fn(pred), ref_fn(ref), block_size(block_size_value),
         bit_depth(bit_depth_value) {}
@@ -446,8 +446,9 @@
                                 const uint16_t *above, const uint16_t *left,
                                 int bps);
 struct HighbdIntraPredParam {
-  HighbdIntraPredParam(HighbdIntraPred pred = NULL, HighbdIntraPred ref = NULL,
-                       int block_size_value = 0, int bit_depth_value = 0)
+  HighbdIntraPredParam(HighbdIntraPred pred = nullptr,
+                       HighbdIntraPred ref = nullptr, int block_size_value = 0,
+                       int bit_depth_value = 0)
       : pred_fn(pred), ref_fn(ref), block_size(block_size_value),
         bit_depth(bit_depth_value) {}
 
--- a/test/vp9_motion_vector_test.cc
+++ b/test/vp9_motion_vector_test.cc
@@ -88,7 +88,7 @@
       "niklas_640_480_30.yuv", VPX_IMG_FMT_I420, 3840, 2160,  // 2048, 1080,
       30, 1, 0, 5));
 
-  ASSERT_TRUE(video.get() != NULL);
+  ASSERT_NE(video.get(), nullptr);
   ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
 }
 
--- a/test/vp9_quantize_test.cc
+++ b/test/vp9_quantize_test.cc
@@ -110,13 +110,13 @@
     vpx_free(quant_ptr_);
     vpx_free(quant_shift_ptr_);
     vpx_free(dequant_ptr_);
-    zbin_ptr_ = NULL;
-    round_fp_ptr_ = NULL;
-    quant_fp_ptr_ = NULL;
-    round_ptr_ = NULL;
-    quant_ptr_ = NULL;
-    quant_shift_ptr_ = NULL;
-    dequant_ptr_ = NULL;
+    zbin_ptr_ = nullptr;
+    round_fp_ptr_ = nullptr;
+    quant_fp_ptr_ = nullptr;
+    round_ptr_ = nullptr;
+    quant_ptr_ = nullptr;
+    quant_shift_ptr_ = nullptr;
+    dequant_ptr_ = nullptr;
     libvpx_test::ClearSystemState();
   }
 
--- a/test/vp9_skip_loopfilter_test.cc
+++ b/test/vp9_skip_loopfilter_test.cc
@@ -24,10 +24,11 @@
 // Class for testing shutting off the loop filter.
 class SkipLoopFilterTest {
  public:
-  SkipLoopFilterTest() : video_(NULL), decoder_(NULL), md5_file_(NULL) {}
+  SkipLoopFilterTest()
+      : video_(nullptr), decoder_(nullptr), md5_file_(nullptr) {}
 
   ~SkipLoopFilterTest() {
-    if (md5_file_ != NULL) fclose(md5_file_);
+    if (md5_file_ != nullptr) fclose(md5_file_);
     delete decoder_;
     delete video_;
   }
@@ -37,8 +38,8 @@
     expected_md5_[0] = '\0';
     junk_[0] = '\0';
     video_ = new libvpx_test::WebMVideoSource(kVp9TestFile);
-    if (video_ == NULL) {
-      EXPECT_TRUE(video_ != NULL);
+    if (video_ == nullptr) {
+      EXPECT_NE(video_, nullptr);
       return false;
     }
     video_->Init();
@@ -47,8 +48,8 @@
     vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
     if (num_threads > 0) cfg.threads = num_threads;
     decoder_ = new libvpx_test::VP9Decoder(cfg, 0);
-    if (decoder_ == NULL) {
-      EXPECT_TRUE(decoder_ != NULL);
+    if (decoder_ == nullptr) {
+      EXPECT_NE(decoder_, nullptr);
       return false;
     }
 
@@ -73,7 +74,7 @@
   }
 
   vpx_codec_err_t DecodeRemainingFrames() {
-    for (; video_->cxdata() != NULL; video_->Next()) {
+    for (; video_->cxdata() != nullptr; video_->Next()) {
       const vpx_codec_err_t res =
           decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
       if (res != VPX_CODEC_OK) return res;
@@ -93,13 +94,13 @@
   // TODO(fgalligan): Move the MD5 testing code into another class.
   void OpenMd5File(const std::string &md5_file_name) {
     md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name);
-    ASSERT_TRUE(md5_file_ != NULL)
+    ASSERT_NE(md5_file_, nullptr)
         << "MD5 file open failed. Filename: " << md5_file_name;
   }
 
   // Reads the next line of the MD5 file.
   void ReadMd5() {
-    ASSERT_TRUE(md5_file_ != NULL);
+    ASSERT_NE(md5_file_, nullptr);
     const int res = fscanf(md5_file_, "%s  %s", expected_md5_, junk_);
     ASSERT_NE(EOF, res) << "Read md5 data failed";
     expected_md5_[32] = '\0';
--- a/test/vp9_thread_test.cc
+++ b/test/vp9_thread_test.cc
@@ -128,18 +128,18 @@
 }
 
 TEST(VPxWorkerThreadTest, TestInterfaceAPI) {
-  EXPECT_EQ(0, vpx_set_worker_interface(NULL));
-  EXPECT_TRUE(vpx_get_worker_interface() != NULL);
+  EXPECT_EQ(0, vpx_set_worker_interface(nullptr));
+  EXPECT_NE(vpx_get_worker_interface(), nullptr);
   for (int i = 0; i < 6; ++i) {
     VPxWorkerInterface winterface = *vpx_get_worker_interface();
     switch (i) {
       default:
-      case 0: winterface.init = NULL; break;
-      case 1: winterface.reset = NULL; break;
-      case 2: winterface.sync = NULL; break;
-      case 3: winterface.launch = NULL; break;
-      case 4: winterface.execute = NULL; break;
-      case 5: winterface.end = NULL; break;
+      case 0: winterface.init = nullptr; break;
+      case 1: winterface.reset = nullptr; break;
+      case 2: winterface.sync = nullptr; break;
+      case 3: winterface.launch = nullptr; break;
+      case 4: winterface.execute = nullptr; break;
+      case 5: winterface.end = nullptr; break;
     }
     EXPECT_EQ(0, vpx_set_worker_interface(&winterface));
   }
@@ -172,7 +172,7 @@
     }
 
     libvpx_test::DxDataIterator dec_iter = decoder.GetDxData();
-    const vpx_image_t *img = NULL;
+    const vpx_image_t *img = nullptr;
 
     // Get decompressed data
     while ((img = dec_iter.Next())) {
@@ -183,7 +183,7 @@
 }
 
 void DecodeFiles(const FileList files[]) {
-  for (const FileList *iter = files; iter->name != NULL; ++iter) {
+  for (const FileList *iter = files; iter->name != nullptr; ++iter) {
     SCOPED_TRACE(iter->name);
     for (int t = 1; t <= 8; ++t) {
       EXPECT_EQ(iter->expected_md5, DecodeFile(iter->name, t))
@@ -245,7 +245,7 @@
                                       "368ebc6ebf3a5e478d85b2c3149b2848" },
                                     { "vp90-2-08-tile_1x8_frame_parallel.webm",
                                       "17e439da2388aff3a0f69cb22579c6c1" },
-                                    { NULL, NULL } };
+                                    { nullptr, nullptr } };
 
   DecodeFiles(files);
 }
@@ -296,7 +296,7 @@
       "ae96f21f21b6370cc0125621b441fc52" },
     { "vp90-2-14-resize-fp-tiles-8-4.webm",
       "3eb4f24f10640d42218f7fd7b9fd30d4" },
-    { NULL, NULL }
+    { nullptr, nullptr }
   };
 
   DecodeFiles(files);
@@ -309,7 +309,7 @@
     { "vp90-2-08-tile_1x8.webm", "0941902a52e9092cb010905eab16364c" },
     { "vp90-2-08-tile-4x1.webm", "06505aade6647c583c8e00a2f582266f" },
     { "vp90-2-08-tile-4x4.webm", "85c2299892460d76e2c600502d52bfe2" },
-    { NULL, NULL }
+    { nullptr, nullptr }
   };
 
   DecodeFiles(files);
--- a/test/y4m_test.cc
+++ b/test/y4m_test.cc
@@ -90,7 +90,7 @@
 
   // Checks y4m header information
   void HeaderChecks(unsigned int bit_depth, vpx_img_fmt_t fmt) {
-    ASSERT_TRUE(input_file_ != NULL);
+    ASSERT_NE(input_file_, nullptr);
     ASSERT_EQ(y4m_.pic_w, (int)kWidth);
     ASSERT_EQ(y4m_.pic_h, (int)kHeight);
     ASSERT_EQ(img()->d_w, kWidth);
@@ -116,7 +116,7 @@
 
   // Checks MD5 of the raw frame data
   void Md5Check(const string &expected_md5) {
-    ASSERT_TRUE(input_file_ != NULL);
+    ASSERT_NE(input_file_, nullptr);
     libvpx_test::MD5 md5;
     for (unsigned int i = start_; i < limit_; i++) {
       md5.Add(img());
@@ -138,11 +138,11 @@
 
 class Y4mVideoWriteTest : public Y4mVideoSourceTest {
  protected:
-  Y4mVideoWriteTest() : tmpfile_(NULL) {}
+  Y4mVideoWriteTest() : tmpfile_(nullptr) {}
 
   virtual ~Y4mVideoWriteTest() {
     delete tmpfile_;
-    input_file_ = NULL;
+    input_file_ = nullptr;
   }
 
   void ReplaceInputFile(FILE *input_file) {
@@ -155,11 +155,11 @@
 
   // Writes out a y4m file and then reads it back
   void WriteY4mAndReadBack() {
-    ASSERT_TRUE(input_file_ != NULL);
+    ASSERT_NE(input_file_, nullptr);
     char buf[Y4M_BUFFER_SIZE] = { 0 };
     const struct VpxRational framerate = { y4m_.fps_n, y4m_.fps_d };
     tmpfile_ = new libvpx_test::TempOutFile;
-    ASSERT_TRUE(tmpfile_->file() != NULL);
+    ASSERT_NE(tmpfile_->file(), nullptr);
     y4m_write_file_header(buf, sizeof(buf), kWidth, kHeight, &framerate,
                           y4m_.vpx_fmt, y4m_.bit_depth);
     fputs(buf, tmpfile_->file());
--- a/vp9/ratectrl_rtc.cc
+++ b/vp9/ratectrl_rtc.cc
@@ -159,7 +159,7 @@
 
 int VP9RateControlRTC::GetLoopfilterLevel() const {
   struct loopfilter *const lf = &cpi_->common.lf;
-  vp9_pick_filter_level(NULL, cpi_, LPF_PICK_FROM_Q);
+  vp9_pick_filter_level(nullptr, cpi_, LPF_PICK_FROM_Q);
   return lf->filter_level;
 }
 
--- a/webmdec.cc
+++ b/webmdec.cc
@@ -19,25 +19,25 @@
 namespace {
 
 void reset(struct WebmInputContext *const webm_ctx) {
-  if (webm_ctx->reader != NULL) {
+  if (webm_ctx->reader != nullptr) {
     mkvparser::MkvReader *const reader =
         reinterpret_cast<mkvparser::MkvReader *>(webm_ctx->reader);
     delete reader;
   }
-  if (webm_ctx->segment != NULL) {
+  if (webm_ctx->segment != nullptr) {
     mkvparser::Segment *const segment =
         reinterpret_cast<mkvparser::Segment *>(webm_ctx->segment);
     delete segment;
   }
-  if (webm_ctx->buffer != NULL) {
+  if (webm_ctx->buffer != nullptr) {
     delete[] webm_ctx->buffer;
   }
-  webm_ctx->reader = NULL;
-  webm_ctx->segment = NULL;
-  webm_ctx->buffer = NULL;
-  webm_ctx->cluster = NULL;
-  webm_ctx->block_entry = NULL;
-  webm_ctx->block = NULL;
+  webm_ctx->reader = nullptr;
+  webm_ctx->segment = nullptr;
+  webm_ctx->buffer = nullptr;
+  webm_ctx->cluster = nullptr;
+  webm_ctx->block_entry = nullptr;
+  webm_ctx->block = nullptr;
   webm_ctx->block_frame_index = 0;
   webm_ctx->video_track_index = 0;
   webm_ctx->timestamp_ns = 0;
@@ -84,7 +84,7 @@
   }
 
   const mkvparser::Tracks *const tracks = segment->GetTracks();
-  const mkvparser::VideoTrack *video_track = NULL;
+  const mkvparser::VideoTrack *video_track = nullptr;
   for (unsigned long i = 0; i < tracks->GetTracksCount(); ++i) {
     const mkvparser::Track *const track = tracks->GetTrackByIndex(i);
     if (track->GetType() == mkvparser::Track::kVideo) {
@@ -94,7 +94,7 @@
     }
   }
 
-  if (video_track == NULL || video_track->GetCodecId() == NULL) {
+  if (video_track == nullptr || video_track->GetCodecId() == nullptr) {
     rewind_and_reset(webm_ctx, vpx_ctx);
     return 0;
   }
@@ -137,12 +137,12 @@
   do {
     long status = 0;
     bool get_new_block = false;
-    if (block_entry == NULL && !block_entry_eos) {
+    if (block_entry == nullptr && !block_entry_eos) {
       status = cluster->GetFirst(block_entry);
       get_new_block = true;
     } else if (block_entry_eos || block_entry->EOS()) {
       cluster = segment->GetNext(cluster);
-      if (cluster == NULL || cluster->EOS()) {
+      if (cluster == nullptr || cluster->EOS()) {
         *buffer_size = 0;
         webm_ctx->reached_eos = 1;
         return 1;
@@ -150,22 +150,22 @@
       status = cluster->GetFirst(block_entry);
       block_entry_eos = false;
       get_new_block = true;
-    } else if (block == NULL ||
+    } else if (block == nullptr ||
                webm_ctx->block_frame_index == block->GetFrameCount() ||
                block->GetTrackNumber() != webm_ctx->video_track_index) {
       status = cluster->GetNext(block_entry, block_entry);
-      if (block_entry == NULL || block_entry->EOS()) {
+      if (block_entry == nullptr || block_entry->EOS()) {
         block_entry_eos = true;
         continue;
       }
       get_new_block = true;
     }
-    if (status || block_entry == NULL) {
+    if (status || block_entry == nullptr) {
       return -1;
     }
     if (get_new_block) {
       block = block_entry->GetBlock();
-      if (block == NULL) return -1;
+      if (block == nullptr) return -1;
       webm_ctx->block_frame_index = 0;
     }
   } while (block_entry_eos ||
@@ -181,7 +181,7 @@
   if (frame.len > static_cast<long>(*buffer_size)) {
     delete[] * buffer;
     *buffer = new uint8_t[frame.len];
-    if (*buffer == NULL) {
+    if (*buffer == nullptr) {
       return -1;
     }
     webm_ctx->buffer = *buffer;
@@ -198,7 +198,7 @@
 int webm_guess_framerate(struct WebmInputContext *webm_ctx,
                          struct VpxInputContext *vpx_ctx) {
   uint32_t i = 0;
-  uint8_t *buffer = NULL;
+  uint8_t *buffer = nullptr;
   size_t buffer_size = 0;
   while (webm_ctx->timestamp_ns < 1000000000 && i < 50) {
     if (webm_read_frame(webm_ctx, &buffer, &buffer_size)) {
@@ -212,8 +212,8 @@
   delete[] buffer;
 
   get_first_cluster(webm_ctx);
-  webm_ctx->block = NULL;
-  webm_ctx->block_entry = NULL;
+  webm_ctx->block = nullptr;
+  webm_ctx->block_entry = nullptr;
   webm_ctx->block_frame_index = 0;
   webm_ctx->timestamp_ns = 0;
   webm_ctx->reached_eos = 0;
--- a/webmenc.cc
+++ b/webmenc.cc
@@ -90,6 +90,6 @@
   segment->Finalize();
   delete segment;
   delete writer;
-  webm_ctx->writer = NULL;
-  webm_ctx->segment = NULL;
+  webm_ctx->writer = nullptr;
+  webm_ctx->segment = nullptr;
 }