mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
229 lines
10 KiB
229 lines
10 KiB
// 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 (vikaas.arora@gmail.com) |
|
// Jyrki Alakuijala (jyrki@google.com) |
|
|
|
#ifndef WEBP_DSP_LOSSLESS_H_ |
|
#define WEBP_DSP_LOSSLESS_H_ |
|
|
|
#include "../webp/types.h" |
|
#include "../webp/decode.h" |
|
|
|
#include "../enc/histogram_enc.h" |
|
#include "../utils/utils.h" |
|
|
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
#ifdef WEBP_EXPERIMENTAL_FEATURES |
|
#include "../enc/delta_palettization_enc.h" |
|
#endif // WEBP_EXPERIMENTAL_FEATURES |
|
|
|
//------------------------------------------------------------------------------ |
|
// Decoding |
|
|
|
typedef uint32_t (*VP8LPredictorFunc)(uint32_t left, const uint32_t* const top); |
|
extern VP8LPredictorFunc VP8LPredictors[16]; |
|
extern VP8LPredictorFunc VP8LPredictors_C[16]; |
|
// These Add/Sub function expects upper[-1] and out[-1] to be readable. |
|
typedef void (*VP8LPredictorAddSubFunc)(const uint32_t* in, |
|
const uint32_t* upper, int num_pixels, |
|
uint32_t* out); |
|
extern VP8LPredictorAddSubFunc VP8LPredictorsAdd[16]; |
|
extern VP8LPredictorAddSubFunc VP8LPredictorsAdd_C[16]; |
|
|
|
typedef void (*VP8LProcessDecBlueAndRedFunc)(const uint32_t* src, |
|
int num_pixels, uint32_t* dst); |
|
extern VP8LProcessDecBlueAndRedFunc VP8LAddGreenToBlueAndRed; |
|
|
|
typedef struct { |
|
// Note: the members are uint8_t, so that any negative values are |
|
// automatically converted to "mod 256" values. |
|
uint8_t green_to_red_; |
|
uint8_t green_to_blue_; |
|
uint8_t red_to_blue_; |
|
} VP8LMultipliers; |
|
typedef void (*VP8LTransformColorInverseFunc)(const VP8LMultipliers* const m, |
|
const uint32_t* src, |
|
int num_pixels, uint32_t* dst); |
|
extern VP8LTransformColorInverseFunc VP8LTransformColorInverse; |
|
|
|
struct VP8LTransform; // Defined in dec/vp8li.h. |
|
|
|
// Performs inverse transform of data given transform information, start and end |
|
// rows. Transform will be applied to rows [row_start, row_end[. |
|
// The *in and *out pointers refer to source and destination data respectively |
|
// corresponding to the intermediate row (row_start). |
|
void VP8LInverseTransform(const struct VP8LTransform* const transform, |
|
int row_start, int row_end, |
|
const uint32_t* const in, uint32_t* const out); |
|
|
|
// Color space conversion. |
|
typedef void (*VP8LConvertFunc)(const uint32_t* src, int num_pixels, |
|
uint8_t* dst); |
|
extern VP8LConvertFunc VP8LConvertBGRAToRGB; |
|
extern VP8LConvertFunc VP8LConvertBGRAToRGBA; |
|
extern VP8LConvertFunc VP8LConvertBGRAToRGBA4444; |
|
extern VP8LConvertFunc VP8LConvertBGRAToRGB565; |
|
extern VP8LConvertFunc VP8LConvertBGRAToBGR; |
|
|
|
// Converts from BGRA to other color spaces. |
|
void VP8LConvertFromBGRA(const uint32_t* const in_data, int num_pixels, |
|
WEBP_CSP_MODE out_colorspace, uint8_t* const rgba); |
|
|
|
typedef void (*VP8LMapARGBFunc)(const uint32_t* src, |
|
const uint32_t* const color_map, |
|
uint32_t* dst, int y_start, |
|
int y_end, int width); |
|
typedef void (*VP8LMapAlphaFunc)(const uint8_t* src, |
|
const uint32_t* const color_map, |
|
uint8_t* dst, int y_start, |
|
int y_end, int width); |
|
|
|
extern VP8LMapARGBFunc VP8LMapColor32b; |
|
extern VP8LMapAlphaFunc VP8LMapColor8b; |
|
|
|
// Similar to the static method ColorIndexInverseTransform() that is part of |
|
// lossless.c, but used only for alpha decoding. It takes uint8_t (rather than |
|
// uint32_t) arguments for 'src' and 'dst'. |
|
void VP8LColorIndexInverseTransformAlpha( |
|
const struct VP8LTransform* const transform, int y_start, int y_end, |
|
const uint8_t* src, uint8_t* dst); |
|
|
|
// Expose some C-only fallback functions |
|
void VP8LTransformColorInverse_C(const VP8LMultipliers* const m, |
|
const uint32_t* src, int num_pixels, |
|
uint32_t* dst); |
|
|
|
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); |
|
void VP8LAddGreenToBlueAndRed_C(const uint32_t* src, int num_pixels, |
|
uint32_t* dst); |
|
|
|
// Must be called before calling any of the above methods. |
|
void VP8LDspInit(void); |
|
|
|
//------------------------------------------------------------------------------ |
|
// Encoding |
|
|
|
typedef void (*VP8LProcessEncBlueAndRedFunc)(uint32_t* dst, int num_pixels); |
|
extern VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed; |
|
typedef void (*VP8LTransformColorFunc)(const VP8LMultipliers* const m, |
|
uint32_t* const dst, int num_pixels); |
|
extern VP8LTransformColorFunc VP8LTransformColor; |
|
typedef void (*VP8LCollectColorBlueTransformsFunc)( |
|
const uint32_t* argb, int stride, |
|
int tile_width, int tile_height, |
|
int green_to_blue, int red_to_blue, int histo[]); |
|
extern VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms; |
|
|
|
typedef void (*VP8LCollectColorRedTransformsFunc)( |
|
const uint32_t* argb, int stride, |
|
int tile_width, int tile_height, |
|
int green_to_red, int histo[]); |
|
extern VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms; |
|
|
|
// Expose some C-only fallback functions |
|
void VP8LTransformColor_C(const VP8LMultipliers* const m, |
|
uint32_t* data, int num_pixels); |
|
void VP8LSubtractGreenFromBlueAndRed_C(uint32_t* argb_data, int num_pixels); |
|
void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride, |
|
int tile_width, int tile_height, |
|
int green_to_red, int histo[]); |
|
void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride, |
|
int tile_width, int tile_height, |
|
int green_to_blue, int red_to_blue, |
|
int histo[]); |
|
|
|
extern VP8LPredictorAddSubFunc VP8LPredictorsSub[16]; |
|
extern VP8LPredictorAddSubFunc VP8LPredictorsSub_C[16]; |
|
|
|
// ----------------------------------------------------------------------------- |
|
// Huffman-cost related functions. |
|
|
|
typedef double (*VP8LCostFunc)(const uint32_t* population, int length); |
|
typedef double (*VP8LCostCombinedFunc)(const uint32_t* X, const uint32_t* Y, |
|
int length); |
|
typedef float (*VP8LCombinedShannonEntropyFunc)(const int X[256], |
|
const int Y[256]); |
|
|
|
extern VP8LCostFunc VP8LExtraCost; |
|
extern VP8LCostCombinedFunc VP8LExtraCostCombined; |
|
extern VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy; |
|
|
|
typedef struct { // small struct to hold counters |
|
int counts[2]; // index: 0=zero steak, 1=non-zero streak |
|
int streaks[2][2]; // [zero/non-zero][streak<3 / streak>=3] |
|
} VP8LStreaks; |
|
|
|
typedef struct { // small struct to hold bit entropy results |
|
double entropy; // entropy |
|
uint32_t sum; // sum of the population |
|
int nonzeros; // number of non-zero elements in the population |
|
uint32_t max_val; // maximum value in the population |
|
uint32_t nonzero_code; // index of the last non-zero in the population |
|
} VP8LBitEntropy; |
|
|
|
void VP8LBitEntropyInit(VP8LBitEntropy* const entropy); |
|
|
|
// Get the combined symbol bit entropy and Huffman cost stats for the |
|
// distributions 'X' and 'Y'. Those results can then be refined according to |
|
// codec specific heuristics. |
|
typedef void (*VP8LGetCombinedEntropyUnrefinedFunc)( |
|
const uint32_t X[], const uint32_t Y[], int length, |
|
VP8LBitEntropy* const bit_entropy, VP8LStreaks* const stats); |
|
extern VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined; |
|
|
|
// Get the entropy for the distribution 'X'. |
|
typedef void (*VP8LGetEntropyUnrefinedFunc)(const uint32_t X[], int length, |
|
VP8LBitEntropy* const bit_entropy, |
|
VP8LStreaks* const stats); |
|
extern VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined; |
|
|
|
void VP8LBitsEntropyUnrefined(const uint32_t* const array, int n, |
|
VP8LBitEntropy* const entropy); |
|
|
|
typedef void (*VP8LHistogramAddFunc)(const VP8LHistogram* const a, |
|
const VP8LHistogram* const b, |
|
VP8LHistogram* const out); |
|
extern VP8LHistogramAddFunc VP8LHistogramAdd; |
|
|
|
// ----------------------------------------------------------------------------- |
|
// PrefixEncode() |
|
|
|
typedef int (*VP8LVectorMismatchFunc)(const uint32_t* const array1, |
|
const uint32_t* const array2, int length); |
|
// Returns the first index where array1 and array2 are different. |
|
extern VP8LVectorMismatchFunc VP8LVectorMismatch; |
|
|
|
typedef void (*VP8LBundleColorMapFunc)(const uint8_t* const row, int width, |
|
int xbits, uint32_t* dst); |
|
extern VP8LBundleColorMapFunc VP8LBundleColorMap; |
|
void VP8LBundleColorMap_C(const uint8_t* const row, int width, int xbits, |
|
uint32_t* dst); |
|
|
|
// Must be called before calling any of the above methods. |
|
void VP8LEncDspInit(void); |
|
|
|
//------------------------------------------------------------------------------ |
|
|
|
#ifdef __cplusplus |
|
} // extern "C" |
|
#endif |
|
|
|
#endif // WEBP_DSP_LOSSLESS_H_
|
|
|