lossless.c | Explore in Territory

// Copyright 2012 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be found in the AUTHORS file in the root of the source tree.
// -----------------------------------------------------------------------------
//
// Image transforms and color space conversion methods for lossless decoder.
//
// Authors: Vikas Arora ([email protected])
//          Jyrki Alakuijala ([email protected])
//          Urvang Joshi ([email protected])

#include "src/dsp/dsp.h"

#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include "src/dec/vp8li_dec.h"
#include "src/utils/endian_inl_utils.h"
#include "src/dsp/lossless.h"
#include "src/dsp/lossless_common.h"

//------------------------------------------------------------------------------
// Image transforms.

static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) { … }

static WEBP_INLINE uint32_t Average3(uint32_t a0, uint32_t a1, uint32_t a2) { … }

static WEBP_INLINE uint32_t Average4(uint32_t a0, uint32_t a1,
                                     uint32_t a2, uint32_t a3) { … }

static WEBP_INLINE uint32_t Clip255(uint32_t a) { … }

static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) { … }

static WEBP_INLINE uint32_t ClampedAddSubtractFull(uint32_t c0, uint32_t c1,
                                                   uint32_t c2) { … }

static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) { … }

static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,
                                                   uint32_t c2) { … }

// gcc <= 4.9 on ARM generates incorrect code in Select() when Sub3() is
// inlined.
#if defined(__arm__) && defined(__GNUC__) && LOCAL_GCC_VERSION <= 0x409
#define LOCAL_INLINE …
#else
#define LOCAL_INLINE …
#endif

static LOCAL_INLINE int Sub3(int a, int b, int c) { … }

#undef LOCAL_INLINE

static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) { … }

//------------------------------------------------------------------------------
// Predictors

uint32_t VP8LPredictor0_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor1_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor2_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor3_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor4_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor5_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor6_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor7_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor8_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor9_C(const uint32_t* const left,
                          const uint32_t* const top) { … }
uint32_t VP8LPredictor10_C(const uint32_t* const left,
                           const uint32_t* const top) { … }
uint32_t VP8LPredictor11_C(const uint32_t* const left,
                           const uint32_t* const top) { … }
uint32_t VP8LPredictor12_C(const uint32_t* const left,
                           const uint32_t* const top) { … }
uint32_t VP8LPredictor13_C(const uint32_t* const left,
                           const uint32_t* const top) { … }

static void PredictorAdd0_C(const uint32_t* in, const uint32_t* upper,
                            int num_pixels, uint32_t* out) { … }
static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
                            int num_pixels, uint32_t* out) { … }
GENERATE_PREDICTOR_ADD(VP8LPredictor2_C, PredictorAdd2_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor3_C, PredictorAdd3_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor4_C, PredictorAdd4_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor5_C, PredictorAdd5_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor6_C, PredictorAdd6_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor7_C, PredictorAdd7_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor8_C, PredictorAdd8_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor9_C, PredictorAdd9_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor10_C, PredictorAdd10_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor11_C, PredictorAdd11_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor12_C, PredictorAdd12_C)
GENERATE_PREDICTOR_ADD(VP8LPredictor13_C, PredictorAdd13_C)

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

// Inverse prediction.
static void PredictorInverseTransform_C(const VP8LTransform* const transform,
                                        int y_start, int y_end,
                                        const uint32_t* in, uint32_t* out) { … }

// Add green to blue and red channels (i.e. perform the inverse transform of
// 'subtract green').
void VP8LAddGreenToBlueAndRed_C(const uint32_t* src, int num_pixels,
                                uint32_t* dst) { … }

static WEBP_INLINE int ColorTransformDelta(int8_t color_pred,
                                           int8_t color) { … }

static WEBP_INLINE void ColorCodeToMultipliers(uint32_t color_code,
                                               VP8LMultipliers* const m) { … }

void VP8LTransformColorInverse_C(const VP8LMultipliers* const m,
                                 const uint32_t* src, int num_pixels,
                                 uint32_t* dst) { … }

// Color space inverse transform.
static void ColorSpaceInverseTransform_C(const VP8LTransform* const transform,
                                         int y_start, int y_end,
                                         const uint32_t* src, uint32_t* dst) { … }

// Separate out pixels packed together using pixel-bundling.
// We define two methods for ARGB data (uint32_t) and alpha-only data (uint8_t).
#define COLOR_INDEX_INVERSE …

COLOR_INDEX_INVERSE
COLOR_INDEX_INVERSE

#undef COLOR_INDEX_INVERSE

void VP8LInverseTransform(const VP8LTransform* const transform,
                          int row_start, int row_end,
                          const uint32_t* const in, uint32_t* const out) { … }

//------------------------------------------------------------------------------
// Color space conversion.

static int is_big_endian(void) { … }

void VP8LConvertBGRAToRGB_C(const uint32_t* src,
                            int num_pixels, uint8_t* dst) { … }

void VP8LConvertBGRAToRGBA_C(const uint32_t* src,
                             int num_pixels, uint8_t* dst) { … }

void VP8LConvertBGRAToRGBA4444_C(const uint32_t* src,
                                 int num_pixels, uint8_t* dst) { … }

void VP8LConvertBGRAToRGB565_C(const uint32_t* src,
                               int num_pixels, uint8_t* dst) { … }

void VP8LConvertBGRAToBGR_C(const uint32_t* src,
                            int num_pixels, uint8_t* dst) { … }

static void CopyOrSwap(const uint32_t* src, int num_pixels, uint8_t* dst,
                       int swap_on_big_endian) { … }

void VP8LConvertFromBGRA(const uint32_t* const in_data, int num_pixels,
                         WEBP_CSP_MODE out_colorspace, uint8_t* const rgba) { … }

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

VP8LProcessDecBlueAndRedFunc VP8LAddGreenToBlueAndRed;
VP8LPredictorAddSubFunc VP8LPredictorsAdd[16];
VP8LPredictorFunc VP8LPredictors[16];

// exposed plain-C implementations
VP8LPredictorAddSubFunc VP8LPredictorsAdd_C[16];

VP8LTransformColorInverseFunc VP8LTransformColorInverse;

VP8LConvertFunc VP8LConvertBGRAToRGB;
VP8LConvertFunc VP8LConvertBGRAToRGBA;
VP8LConvertFunc VP8LConvertBGRAToRGBA4444;
VP8LConvertFunc VP8LConvertBGRAToRGB565;
VP8LConvertFunc VP8LConvertBGRAToBGR;

VP8LMapARGBFunc VP8LMapColor32b;
VP8LMapAlphaFunc VP8LMapColor8b;

extern VP8CPUInfo VP8GetCPUInfo;
extern void VP8LDspInitSSE2(void);
extern void VP8LDspInitSSE41(void);
extern void VP8LDspInitNEON(void);
extern void VP8LDspInitMIPSdspR2(void);
extern void VP8LDspInitMSA(void);

#define COPY_PREDICTOR_ARRAY …

WEBP_DSP_INIT_FUNC(VP8LDspInit) { … }
#undef COPY_PREDICTOR_ARRAY

//------------------------------------------------------------------------------
godot/thirdparty/libwebp/src/dsp/lossless.c
