tests/test_global_params.cc

// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "include/helpers.h"
#include "src/common/global_params.h"
#include "src/enc/wp2_enc_i.h"
#include "src/utils/data_source.h"

using testing::AssertionResult;

namespace WP2 {
namespace {

WP2Status WriteAndRead(const GlobalParams& params_to_write,
                       GlobalParams* read_params) {
  ANSEnc enc;
  constexpr bool kImageHasAlpha = true;
  WP2_CHECK_STATUS(params_to_write.Write(kImageHasAlpha, &enc));
  WP2_CHECK_STATUS(enc.AssembleToBitstream());
  Vector_u8 bits;
  WP2_CHECK_STATUS(enc.WriteBitstreamTo(bits));
  ExternalDataSource data_source(bits.data(), bits.size());
  ANSDec dec(&data_source);
  WP2_CHECK_STATUS(read_params->Read(kImageHasAlpha, &dec));
  WP2_CHECK_OK(read_params->IsOk(), WP2_STATUS_BAD_READ);
  return WP2_STATUS_OK;
}

TEST(GlobalParmas, ReadWriteUVQUantMultiplier) {
  GlobalParams params;
  ASSERT_TRUE(params.segments_.resize(3));
  params.u_quant_offset_ = kDefaultQuantOffset;
  params.v_quant_offset_ = kDefaultQuantOffset + 2;
  for (Segment& s : params.segments_) {
    s.SetYUVBounds(-512, 512);
    s.SetQuality(/*quality_factor=*/10, params.u_quant_offset_,
                 params.v_quant_offset_);
    s.FinalizeQuant();
  }
  params.yuv_filter_magnitude_ = kMaxYuvFilterMagnitude / 2;
  ASSERT_TRUE(params.IsOk());

  GlobalParams read_params;
  ASSERT_WP2_OK(WriteAndRead(params, &read_params));
  EXPECT_EQ(read_params.u_quant_offset_, kDefaultQuantOffset);
  EXPECT_EQ(read_params.v_quant_offset_, kDefaultQuantOffset + 2);

  params.u_quant_offset_ = kDefaultQuantOffset;
  params.v_quant_offset_ = kDefaultQuantOffset - 3;
  ASSERT_WP2_OK(WriteAndRead(params, &read_params));
  EXPECT_EQ(read_params.u_quant_offset_, kDefaultQuantOffset);
  EXPECT_EQ(read_params.v_quant_offset_, kDefaultQuantOffset - 3);

  params.u_quant_offset_ = kDefaultQuantOffset - 2;
  params.v_quant_offset_ = kDefaultQuantOffset + 1;
  ASSERT_WP2_OK(WriteAndRead(params, &read_params));
  EXPECT_EQ(read_params.u_quant_offset_, kDefaultQuantOffset - 2);
  EXPECT_EQ(read_params.v_quant_offset_, kDefaultQuantOffset + 1);
}

TEST(GlobalParmas, FixedPredictors) {
  GlobalParams params;
  ASSERT_TRUE(params.segments_.resize(3));
  params.has_alpha_ = params.maybe_use_lossy_alpha_ = true;
  // Init twice (should not matter).
  ASSERT_WP2_OK(params.InitFixedPredictors());
  ASSERT_WP2_OK(params.InitFixedPredictors());
  EXPECT_EQ(params.y_preds_.size(), kYPredNum);
  EXPECT_EQ(params.y_preds_.GetMaxMode(), kYPredModeNum - 1);
  EXPECT_EQ(params.uv_preds_.size(), kUVPredNum);
  EXPECT_EQ(params.a_preds_.size(), kAPredNum);
  EXPECT_EQ(params.a_preds_.GetMaxMode(), kAPredModeNum - 1);

  GlobalParams read_params;
  ASSERT_WP2_OK(WriteAndRead(params, &read_params));
  EXPECT_EQ(read_params.y_preds_.size(), kYPredNum);
  EXPECT_EQ(read_params.y_preds_.GetMaxMode(), kYPredModeNum - 1);
  EXPECT_EQ(read_params.uv_preds_.size(), kUVPredNum);
  EXPECT_EQ(read_params.a_preds_.size(), kAPredNum);
  EXPECT_EQ(read_params.a_preds_.GetMaxMode(), kAPredModeNum - 1);
}

}  // namespace
}  // namespace WP2