aviftest_helpers.cc | Explore in Territory

// Copyright 2022 Google LLC
// SPDX-License-Identifier: BSD-2-Clause

#include "aviftest_helpers.h"

#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <limits>
#include <string>
#include <vector>

#include "avif/avif.h"
#include "avif/avif_cxx.h"
#include "avifpng.h"
#include "avifutil.h"

namespace avif {
namespace testutil {

//------------------------------------------------------------------------------
// CopyImageSamples is a copy of avifImageCopySamples

namespace {
void CopyImageSamples(avifImage* dstImage, const avifImage* srcImage,
                      avifPlanesFlags planes) { … }
}  // namespace

//------------------------------------------------------------------------------

AvifRgbImage::AvifRgbImage(const avifImage* yuv, int rgbDepth,
                           avifRGBFormat rgbFormat) { … }

AvifRwData::AvifRwData(AvifRwData&& other) : … { … }

//------------------------------------------------------------------------------

RgbChannelOffsets GetRgbChannelOffsets(avifRGBFormat format) { … }

//------------------------------------------------------------------------------

ImagePtr CreateImage(int width, int height, int depth,
                     avifPixelFormat yuv_format, avifPlanesFlags planes,
                     avifRange yuv_range) { … }

void FillImagePlain(avifImage* image, const uint32_t yuva[4]) { … }

void FillImageGradient(avifImage* image) { … }

namespace {
template <typename PixelType>
void FillImageChannel(avifRGBImage* image, uint32_t channel_offset,
                      uint32_t value) { … }
}  // namespace

void FillImageChannel(avifRGBImage* image, uint32_t channel_offset,
                      uint32_t value) { … }

//------------------------------------------------------------------------------

bool AreByteSequencesEqual(const uint8_t data1[], size_t data1_length,
                           const uint8_t data2[], size_t data2_length) { … }

bool AreByteSequencesEqual(const avifRWData& data1, const avifRWData& data2) { … }

// Returns true if image1 and image2 are identical.
bool AreImagesEqual(const avifImage& image1, const avifImage& image2,
                    bool ignore_alpha) { … }

namespace {

template <typename Sample>
uint64_t SquaredDiffSum(const Sample* samples1, const Sample* samples2,
                        uint32_t num_samples) { … }

}  // namespace

double GetPsnr(const avifImage& image1, const avifImage& image2,
               bool ignore_alpha) { … }

bool AreImagesEqual(const avifRGBImage& image1, const avifRGBImage& image2) { … }

avifResult MergeGrid(int grid_cols, int grid_rows,
                     const std::vector<ImagePtr>& cells, avifImage* merged) { … }

avifResult MergeGrid(int grid_cols, int grid_rows,
                     const std::vector<const avifImage*>& cells,
                     avifImage* merged) { … }

//------------------------------------------------------------------------------

testutil::AvifRwData ReadFile(const std::string& file_path) { … }

//------------------------------------------------------------------------------

ImagePtr ReadImage(const char* folder_path, const char* file_name,
                   avifPixelFormat requested_format, int requested_depth,
                   avifChromaDownsampling chroma_downsampling,
                   avifBool ignore_icc, avifBool ignore_exif,
                   avifBool ignore_xmp, avifBool allow_changing_cicp,
                   avifBool ignore_gain_map) { … }

bool WriteImage(const avifImage* image, const char* file_path) { … }

AvifRwData Encode(const avifImage* image, int speed, int quality) { … }

ImagePtr Decode(const uint8_t* bytes, size_t num_bytes) { … }

ImagePtr DecodeFile(const std::string& path) { … }

bool Av1EncoderAvailable() { … }

bool Av1DecoderAvailable() { … }

//------------------------------------------------------------------------------

static avifResult avifIOLimitedReaderRead(avifIO* io, uint32_t readFlags,
                                          uint64_t offset, size_t size,
                                          avifROData* out) { … }

static void avifIOLimitedReaderDestroy(avifIO* io) { … }

avifIO* AvifIOCreateLimitedReader(avifIO* underlyingIO, uint64_t clamp) { … }

//------------------------------------------------------------------------------

std::vector<ImagePtr> ImageToGrid(const avifImage* image, uint32_t grid_cols,
                                  uint32_t grid_rows) { … }

std::vector<const avifImage*> UniquePtrToRawPtr(
    const std::vector<ImagePtr>& unique_ptrs) { … }

//------------------------------------------------------------------------------

}  // namespace testutil
}  // namespace avif
chromium/third_party/libavif/src/tests/gtest/aviftest_helpers.cc
