generic-library/webp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge "rename some symbols clashing with MSVC headers"

Browse Source
This commit is contained in:
Pascal Massimino 2017-03-16 17:53:37 +00:00 committed by Gerrit Code Review
commit bb175a935e
2 changed files with 24 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/mux/anim_encode.c
View File

@ -35,7 +35,7 @@
// Stores frame rectangle dimensions. // Stores frame rectangle dimensions.
typedef struct { typedef struct {
int x_offset_, y_offset_, width_, height_; int x_offset_, y_offset_, width_, height_;
} FrameRect; } FrameRectangle;
// Used to store two candidates of encoded data for an animation frame. One of // Used to store two candidates of encoded data for an animation frame. One of
// the two will be chosen later. // the two will be chosen later.
@ -50,7 +50,7 @@ struct WebPAnimEncoder {
const int canvas_height_; // Canvas height. const int canvas_height_; // Canvas height.
const WebPAnimEncoderOptions options_; // Global encoding options. const WebPAnimEncoderOptions options_; // Global encoding options.
FrameRect prev_rect_; // Previous WebP frame rectangle. FrameRectangle prev_rect_; // Previous WebP frame rectangle.
WebPConfig last_config_; // Cached in case a re-encode is needed. WebPConfig last_config_; // Cached in case a re-encode is needed.
WebPConfig last_config_reversed_; // If 'last_config_' uses lossless, then WebPConfig last_config_reversed_; // If 'last_config_' uses lossless, then
// this config uses lossy and vice versa; // this config uses lossy and vice versa;
@ -206,7 +206,7 @@ static void ClearRectangle(WebPPicture* const picture,
} }
static void WebPUtilClearPic(WebPPicture* const picture, static void WebPUtilClearPic(WebPPicture* const picture,
const FrameRect* const rect) { const FrameRectangle* const rect) {
if (rect != NULL) { if (rect != NULL) {
ClearRectangle(picture, rect->x_offset_, rect->y_offset_, ClearRectangle(picture, rect->x_offset_, rect->y_offset_,
rect->width_, rect->height_); rect->width_, rect->height_);
@ -400,7 +400,7 @@ static WEBP_INLINE int ComparePixelsLossy(const uint32_t* src, int src_step,
return 1; return 1;
} }
static int IsEmptyRect(const FrameRect* const rect) { static int IsEmptyRect(const FrameRectangle* const rect) {
return (rect->width_ == 0) || (rect->height_ == 0); return (rect->width_ == 0) || (rect->height_ == 0);
} }
@ -413,7 +413,7 @@ static int QualityToMaxDiff(float quality) {
// Assumes that an initial valid guess of change rectangle 'rect' is passed. // Assumes that an initial valid guess of change rectangle 'rect' is passed.
static void MinimizeChangeRectangle(const WebPPicture* const src, static void MinimizeChangeRectangle(const WebPPicture* const src,
const WebPPicture* const dst, const WebPPicture* const dst,
FrameRect* const rect, FrameRectangle* const rect,
int is_lossless, float quality) { int is_lossless, float quality) {
int i, j; int i, j;
const ComparePixelsFunc compare_pixels = const ComparePixelsFunc compare_pixels =
@ -498,7 +498,7 @@ static void MinimizeChangeRectangle(const WebPPicture* const src,
} }
// Snap rectangle to even offsets (and adjust dimensions if needed). // Snap rectangle to even offsets (and adjust dimensions if needed).
static WEBP_INLINE void SnapToEvenOffsets(FrameRect* const rect) { static WEBP_INLINE void SnapToEvenOffsets(FrameRectangle* const rect) {
rect->width_ += (rect->x_offset_ & 1); rect->width_ += (rect->x_offset_ & 1);
rect->height_ += (rect->y_offset_ & 1); rect->height_ += (rect->y_offset_ & 1);
rect->x_offset_ &= ~1; rect->x_offset_ &= ~1;
@ -508,9 +508,9 @@ static WEBP_INLINE void SnapToEvenOffsets(FrameRect* const rect) {
typedef struct { typedef struct {
int should_try_; // Should try this set of parameters. int should_try_; // Should try this set of parameters.
int empty_rect_allowed_; // Frame with empty rectangle can be skipped. int empty_rect_allowed_; // Frame with empty rectangle can be skipped.
FrameRect rect_ll_; // Frame rectangle for lossless compression. FrameRectangle rect_ll_; // Frame rectangle for lossless compression.
WebPPicture sub_frame_ll_; // Sub-frame pic for lossless compression. WebPPicture sub_frame_ll_; // Sub-frame pic for lossless compression.
FrameRect rect_lossy_; // Frame rectangle for lossy compression. FrameRectangle rect_lossy_; // Frame rectangle for lossy compression.
// Could be smaller than rect_ll_ as pixels // Could be smaller than rect_ll_ as pixels
// with small diffs can be ignored. // with small diffs can be ignored.
WebPPicture sub_frame_lossy_; // Sub-frame pic for lossless compression. WebPPicture sub_frame_lossy_; // Sub-frame pic for lossless compression.
@ -538,7 +538,8 @@ static void SubFrameParamsFree(SubFrameParams* const params) {
static int GetSubRect(const WebPPicture* const prev_canvas, static int GetSubRect(const WebPPicture* const prev_canvas,
const WebPPicture* const curr_canvas, int is_key_frame, const WebPPicture* const curr_canvas, int is_key_frame,
int is_first_frame, int empty_rect_allowed, int is_first_frame, int empty_rect_allowed,
int is_lossless, float quality, FrameRect* const rect, int is_lossless, float quality,
FrameRectangle* const rect,
WebPPicture* const sub_frame) { WebPPicture* const sub_frame) {
if (!is_key_frame || is_first_frame) { // Optimize frame rectangle. if (!is_key_frame || is_first_frame) { // Optimize frame rectangle.
// Note: This behaves as expected for first frame, as 'prev_canvas' is // Note: This behaves as expected for first frame, as 'prev_canvas' is
@ -594,7 +595,7 @@ int WebPAnimEncoderRefineRect(
const WebPPicture* const prev_canvas, const WebPPicture* const curr_canvas, const WebPPicture* const prev_canvas, const WebPPicture* const curr_canvas,
int is_lossless, float quality, int* const x_offset, int* const y_offset, int is_lossless, float quality, int* const x_offset, int* const y_offset,
int* const width, int* const height) { int* const width, int* const height) {
FrameRect rect; FrameRectangle rect;
const int right = clip(*x_offset + *width, 0, curr_canvas->width); const int right = clip(*x_offset + *width, 0, curr_canvas->width);
const int left = clip(*x_offset, 0, curr_canvas->width - 1); const int left = clip(*x_offset, 0, curr_canvas->width - 1);
const int bottom = clip(*y_offset + *height, 0, curr_canvas->height); const int bottom = clip(*y_offset + *height, 0, curr_canvas->height);
@ -620,7 +621,7 @@ int WebPAnimEncoderRefineRect(
} }
static void DisposeFrameRectangle(int dispose_method, static void DisposeFrameRectangle(int dispose_method,
const FrameRect* const rect, const FrameRectangle* const rect,
WebPPicture* const curr_canvas) { WebPPicture* const curr_canvas) {
assert(rect != NULL); assert(rect != NULL);
if (dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) { if (dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
@ -628,13 +629,13 @@ static void DisposeFrameRectangle(int dispose_method,
} }
} }
static uint32_t RectArea(const FrameRect* const rect) { static uint32_t RectArea(const FrameRectangle* const rect) {
return (uint32_t)rect->width_ * rect->height_; return (uint32_t)rect->width_ * rect->height_;
} }
static int IsLosslessBlendingPossible(const WebPPicture* const src, static int IsLosslessBlendingPossible(const WebPPicture* const src,
const WebPPicture* const dst, const WebPPicture* const dst,
const FrameRect* const rect) { const FrameRectangle* const rect) {
int i, j; int i, j;
assert(src->width == dst->width && src->height == dst->height); assert(src->width == dst->width && src->height == dst->height);
assert(rect->x_offset_ + rect->width_ <= dst->width); assert(rect->x_offset_ + rect->width_ <= dst->width);
@ -656,7 +657,7 @@ static int IsLosslessBlendingPossible(const WebPPicture* const src,
static int IsLossyBlendingPossible(const WebPPicture* const src, static int IsLossyBlendingPossible(const WebPPicture* const src,
const WebPPicture* const dst, const WebPPicture* const dst,
const FrameRect* const rect, const FrameRectangle* const rect,
float quality) { float quality) {
const int max_allowed_diff_lossy = QualityToMaxDiff(quality); const int max_allowed_diff_lossy = QualityToMaxDiff(quality);
int i, j; int i, j;
@ -683,7 +684,7 @@ static int IsLossyBlendingPossible(const WebPPicture* const src,
// transparent pixels. // transparent pixels.
// Returns true if at least one pixel gets modified. // Returns true if at least one pixel gets modified.
static int IncreaseTransparency(const WebPPicture* const src, static int IncreaseTransparency(const WebPPicture* const src,
const FrameRect* const rect, const FrameRectangle* const rect,
WebPPicture* const dst) { WebPPicture* const dst) {
int i, j; int i, j;
int modified = 0; int modified = 0;
@ -709,7 +710,7 @@ static int IncreaseTransparency(const WebPPicture* const src,
// Assumes lossy compression is being used. // Assumes lossy compression is being used.
// Returns true if at least one pixel gets modified. // Returns true if at least one pixel gets modified.
static int FlattenSimilarBlocks(const WebPPicture* const src, static int FlattenSimilarBlocks(const WebPPicture* const src,
const FrameRect* const rect, const FrameRectangle* const rect,
WebPPicture* const dst, float quality) { WebPPicture* const dst, float quality) {
const int max_allowed_diff_lossy = QualityToMaxDiff(quality); const int max_allowed_diff_lossy = QualityToMaxDiff(quality);
int i, j; int i, j;
@ -778,13 +779,13 @@ static int EncodeFrame(const WebPConfig* const config, WebPPicture* const pic,
typedef struct { typedef struct {
WebPMemoryWriter mem_; WebPMemoryWriter mem_;
WebPMuxFrameInfo info_; WebPMuxFrameInfo info_;
FrameRect rect_; FrameRectangle rect_;
int evaluate_; // True if this candidate should be evaluated. int evaluate_; // True if this candidate should be evaluated.
} Candidate; } Candidate;
// Generates a candidate encoded frame given a picture and metadata. // Generates a candidate encoded frame given a picture and metadata.
static WebPEncodingError EncodeCandidate(WebPPicture* const sub_frame, static WebPEncodingError EncodeCandidate(WebPPicture* const sub_frame,
const FrameRect* const rect, const FrameRectangle* const rect,
const WebPConfig* const encoder_config, const WebPConfig* const encoder_config,
int use_blending, int use_blending,
Candidate* const candidate) { Candidate* const candidate) {
@ -958,7 +959,7 @@ static int IncreasePreviousDuration(WebPAnimEncoder* const enc, int duration) {
if (new_duration >= MAX_DURATION) { // Special case. if (new_duration >= MAX_DURATION) { // Special case.
// Separate out previous frame from earlier merged frames to avoid overflow. // Separate out previous frame from earlier merged frames to avoid overflow.
// We add a 1x1 transparent frame for the previous frame, with blending on. // We add a 1x1 transparent frame for the previous frame, with blending on.
const FrameRect rect = { 0, 0, 1, 1 }; const FrameRectangle rect = { 0, 0, 1, 1 };
const uint8_t lossless_1x1_bytes[] = { const uint8_t lossless_1x1_bytes[] = {
0x52, 0x49, 0x46, 0x46, 0x14, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50, 0x52, 0x49, 0x46, 0x46, 0x14, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50,
0x56, 0x50, 0x38, 0x4c, 0x08, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x56, 0x50, 0x38, 0x4c, 0x08, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
@ -1223,7 +1224,7 @@ static int CacheFrame(WebPAnimEncoder* const enc,
enc->prev_candidate_undecided_ = 0; enc->prev_candidate_undecided_ = 0;
} else { } else {
int64_t curr_delta; int64_t curr_delta;
FrameRect prev_rect_key, prev_rect_sub; FrameRectangle prev_rect_key, prev_rect_sub;
// Add this as a frame rectangle to enc. // Add this as a frame rectangle to enc.
error_code = SetFrame(enc, config, 0, encoded_frame, &frame_skipped); error_code = SetFrame(enc, config, 0, encoded_frame, &frame_skipped);

5
src/utils/quant_levels_dec_utils.c
View File

@ -71,10 +71,11 @@ typedef struct {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
#define CLIP_MASK (int)(~0U << (8 + DFIX)) #define CLIP_8b_MASK (int)(~0U << (8 + DFIX))
static WEBP_INLINE uint8_t clip_8b(int v) { static WEBP_INLINE uint8_t clip_8b(int v) {
return (!(v & CLIP_MASK)) ? (uint8_t)(v >> DFIX) : (v < 0) ? 0u : 255u; return (!(v & CLIP_8b_MASK)) ? (uint8_t)(v >> DFIX) : (v < 0) ? 0u : 255u;
} }
#undef CLIP_8b_MASK
// vertical accumulation // vertical accumulation
static void VFilter(SmoothParams* const p) { static void VFilter(SmoothParams* const p) {