// 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. // ----------------------------------------------------------------------------- // // Author: Jyrki Alakuijala (jyrki@google.com) // #ifndef WEBP_ENC_BACKWARD_REFERENCES_ENC_H_ #define WEBP_ENC_BACKWARD_REFERENCES_ENC_H_ #include <assert.h> #include <stdlib.h> #include "src/webp/types.h" #include "src/webp/format_constants.h" #ifdef __cplusplus extern "C" { #endif // The maximum allowed limit is 11. #define MAX_COLOR_CACHE_BITS 10 // ----------------------------------------------------------------------------- // PixOrCopy enum Mode { kLiteral, kCacheIdx, kCopy, kNone }; typedef struct { // mode as uint8_t to make the memory layout to be exactly 8 bytes. uint8_t mode; uint16_t len; uint32_t argb_or_distance; } PixOrCopy; static WEBP_INLINE PixOrCopy PixOrCopyCreateCopy(uint32_t distance, uint16_t len) { PixOrCopy retval; retval.mode = kCopy; retval.argb_or_distance = distance; retval.len = len; return retval; } static WEBP_INLINE PixOrCopy PixOrCopyCreateCacheIdx(int idx) { PixOrCopy retval; assert(idx >= 0); assert(idx < (1 << MAX_COLOR_CACHE_BITS)); retval.mode = kCacheIdx; retval.argb_or_distance = idx; retval.len = 1; return retval; } static WEBP_INLINE PixOrCopy PixOrCopyCreateLiteral(uint32_t argb) { PixOrCopy retval; retval.mode = kLiteral; retval.argb_or_distance = argb; retval.len = 1; return retval; } static WEBP_INLINE int PixOrCopyIsLiteral(const PixOrCopy* const p) { return (p->mode == kLiteral); } static WEBP_INLINE int PixOrCopyIsCacheIdx(const PixOrCopy* const p) { return (p->mode == kCacheIdx); } static WEBP_INLINE int PixOrCopyIsCopy(const PixOrCopy* const p) { return (p->mode == kCopy); } static WEBP_INLINE uint32_t PixOrCopyLiteral(const PixOrCopy* const p, int component) { assert(p->mode == kLiteral); return (p->argb_or_distance >> (component * 8)) & 0xff; } static WEBP_INLINE uint32_t PixOrCopyLength(const PixOrCopy* const p) { return p->len; } static WEBP_INLINE uint32_t PixOrCopyCacheIdx(const PixOrCopy* const p) { assert(p->mode == kCacheIdx); assert(p->argb_or_distance < (1U << MAX_COLOR_CACHE_BITS)); return p->argb_or_distance; } static WEBP_INLINE uint32_t PixOrCopyDistance(const PixOrCopy* const p) { assert(p->mode == kCopy); return p->argb_or_distance; } // ----------------------------------------------------------------------------- // VP8LHashChain #define HASH_BITS 18 #define HASH_SIZE (1 << HASH_BITS) // If you change this, you need MAX_LENGTH_BITS + WINDOW_SIZE_BITS <= 32 as it // is used in VP8LHashChain. #define MAX_LENGTH_BITS 12 #define WINDOW_SIZE_BITS 20 // We want the max value to be attainable and stored in MAX_LENGTH_BITS bits. #define MAX_LENGTH ((1 << MAX_LENGTH_BITS) - 1) #if MAX_LENGTH_BITS + WINDOW_SIZE_BITS > 32 #error "MAX_LENGTH_BITS + WINDOW_SIZE_BITS > 32" #endif typedef struct VP8LHashChain VP8LHashChain; struct VP8LHashChain { // The 20 most significant bits contain the offset at which the best match // is found. These 20 bits are the limit defined by GetWindowSizeForHashChain // (through WINDOW_SIZE = 1<<20). // The lower 12 bits contain the length of the match. The 12 bit limit is // defined in MaxFindCopyLength with MAX_LENGTH=4096. uint32_t* offset_length_; // This is the maximum size of the hash_chain that can be constructed. // Typically this is the pixel count (width x height) for a given image. int size_; }; // Must be called first, to set size. int VP8LHashChainInit(VP8LHashChain* const p, int size); // Pre-compute the best matches for argb. int VP8LHashChainFill(VP8LHashChain* const p, int quality, const uint32_t* const argb, int xsize, int ysize, int low_effort); void VP8LHashChainClear(VP8LHashChain* const p); // release memory static WEBP_INLINE int VP8LHashChainFindOffset(const VP8LHashChain* const p, const int base_position) { return p->offset_length_[base_position] >> MAX_LENGTH_BITS; } static WEBP_INLINE int VP8LHashChainFindLength(const VP8LHashChain* const p, const int base_position) { return p->offset_length_[base_position] & ((1U << MAX_LENGTH_BITS) - 1); } static WEBP_INLINE void VP8LHashChainFindCopy(const VP8LHashChain* const p, int base_position, int* const offset_ptr, int* const length_ptr) { *offset_ptr = VP8LHashChainFindOffset(p, base_position); *length_ptr = VP8LHashChainFindLength(p, base_position); } // ----------------------------------------------------------------------------- // VP8LBackwardRefs (block-based backward-references storage) // maximum number of reference blocks the image will be segmented into #define MAX_REFS_BLOCK_PER_IMAGE 16 typedef struct PixOrCopyBlock PixOrCopyBlock; // forward declaration typedef struct VP8LBackwardRefs VP8LBackwardRefs; // Container for blocks chain struct VP8LBackwardRefs { int block_size_; // common block-size int error_; // set to true if some memory error occurred PixOrCopyBlock* refs_; // list of currently used blocks PixOrCopyBlock** tail_; // for list recycling PixOrCopyBlock* free_blocks_; // free-list PixOrCopyBlock* last_block_; // used for adding new refs (internal) }; // Initialize the object. 'block_size' is the common block size to store // references (typically, width * height / MAX_REFS_BLOCK_PER_IMAGE). void VP8LBackwardRefsInit(VP8LBackwardRefs* const refs, int block_size); // Release memory for backward references. void VP8LBackwardRefsClear(VP8LBackwardRefs* const refs); // Cursor for iterating on references content typedef struct { // public: PixOrCopy* cur_pos; // current position // private: PixOrCopyBlock* cur_block_; // current block in the refs list const PixOrCopy* last_pos_; // sentinel for switching to next block } VP8LRefsCursor; // Returns a cursor positioned at the beginning of the references list. VP8LRefsCursor VP8LRefsCursorInit(const VP8LBackwardRefs* const refs); // Returns true if cursor is pointing at a valid position. static WEBP_INLINE int VP8LRefsCursorOk(const VP8LRefsCursor* const c) { return (c->cur_pos != NULL); } // Move to next block of references. Internal, not to be called directly. void VP8LRefsCursorNextBlock(VP8LRefsCursor* const c); // Move to next position, or NULL. Should not be called if !VP8LRefsCursorOk(). static WEBP_INLINE void VP8LRefsCursorNext(VP8LRefsCursor* const c) { assert(c != NULL); assert(VP8LRefsCursorOk(c)); if (++c->cur_pos == c->last_pos_) VP8LRefsCursorNextBlock(c); } // ----------------------------------------------------------------------------- // Main entry points enum VP8LLZ77Type { kLZ77Standard = 1, kLZ77RLE = 2, kLZ77Box = 4 }; // Evaluates best possible backward references for specified quality. // The input cache_bits to 'VP8LGetBackwardReferences' sets the maximum cache // bits to use (passing 0 implies disabling the local color cache). // The optimal cache bits is evaluated and set for the *cache_bits parameter. // The return value is the pointer to the best of the two backward refs viz, // refs[0] or refs[1]. VP8LBackwardRefs* VP8LGetBackwardReferences( int width, int height, const uint32_t* const argb, int quality, int low_effort, int lz77_types_to_try, int* const cache_bits, const VP8LHashChain* const hash_chain, VP8LBackwardRefs* const refs_tmp1, VP8LBackwardRefs* const refs_tmp2); #ifdef __cplusplus } #endif #endif // WEBP_ENC_BACKWARD_REFERENCES_ENC_H_