Intermediate changes

commit_hash:9e9c04347de10235f77fcdaf62119e9b89e8bc59

1 files changed, 378 insertions, 376 deletions

diff --git a/contrib/libs/libwebp/src/mux/anim_encode.c b/contrib/libs/libwebp/src/mux/anim_encode.c
index deeb414ad6b..baf4f816d37 100644
--- a/contrib/libs/libwebp/src/mux/anim_encode.c
+++ b/contrib/libs/libwebp/src/mux/anim_encode.c
@@ -15,6 +15,7 @@
 #include <math.h>    // for pow()
 #include <stdio.h>
 #include <stdlib.h>  // for abs()
+#include <string.h>
 
 #include "src/mux/animi.h"
 #include "src/utils/utils.h"
@@ -22,6 +23,7 @@
 #include "src/webp/encode.h"
 #include "src/webp/format_constants.h"
 #include "src/webp/mux.h"
+#include "src/webp/mux_types.h"
 #include "src/webp/types.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1900
@@ -35,70 +37,70 @@
 
 // Stores frame rectangle dimensions.
 typedef struct {
-  int x_offset_, y_offset_, width_, height_;
+  int x_offset, y_offset, width, height;
 } FrameRectangle;
 
 // Used to store two candidates of encoded data for an animation frame. One of
 // the two will be chosen later.
 typedef struct {
-  WebPMuxFrameInfo sub_frame_;  // Encoded frame rectangle.
-  WebPMuxFrameInfo key_frame_;  // Encoded frame if it is a key-frame.
-  int is_key_frame_;            // True if 'key_frame' has been chosen.
+  WebPMuxFrameInfo sub_frame;  // Encoded frame rectangle.
+  WebPMuxFrameInfo key_frame;  // Encoded frame if it is a key-frame.
+  int is_key_frame;            // True if 'key_frame' has been chosen.
 } EncodedFrame;
 
 struct WebPAnimEncoder {
-  const int canvas_width_;                  // Canvas width.
-  const int canvas_height_;                 // Canvas height.
-  const WebPAnimEncoderOptions options_;    // Global encoding options.
+  const int canvas_width;                  // Canvas width.
+  const int canvas_height;                 // Canvas height.
+  const WebPAnimEncoderOptions options;    // Global encoding options.
 
-  FrameRectangle prev_rect_;          // Previous WebP frame rectangle.
-  WebPConfig last_config_;            // Cached in case a re-encode is needed.
-  WebPConfig last_config_reversed_;   // If 'last_config_' uses lossless, then
+  FrameRectangle prev_rect;           // Previous WebP frame rectangle.
+  WebPConfig last_config;             // Cached in case a re-encode is needed.
+  WebPConfig last_config_reversed;    // If 'last_config' uses lossless, then
                                       // this config uses lossy and vice versa;
-                                      // only valid if 'options_.allow_mixed'
+                                      // only valid if 'options.allow_mixed'
                                       // is true.
 
-  WebPPicture* curr_canvas_;          // Only pointer; we don't own memory.
+  WebPPicture* curr_canvas;           // Only pointer; we don't own memory.
 
   // Canvas buffers.
-  WebPPicture curr_canvas_copy_;      // Possibly modified current canvas.
-  int curr_canvas_copy_modified_;     // True if pixels in 'curr_canvas_copy_'
-                                      // differ from those in 'curr_canvas_'.
+  WebPPicture curr_canvas_copy;       // Possibly modified current canvas.
+  int curr_canvas_copy_modified;      // True if pixels in 'curr_canvas_copy'
+                                      // differ from those in 'curr_canvas'.
 
-  WebPPicture prev_canvas_;           // Previous canvas.
-  WebPPicture prev_canvas_disposed_;  // Previous canvas disposed to background.
+  WebPPicture prev_canvas;            // Previous canvas.
+  WebPPicture prev_canvas_disposed;   // Previous canvas disposed to background.
 
   // Encoded data.
-  EncodedFrame* encoded_frames_;      // Array of encoded frames.
-  size_t size_;             // Number of allocated frames.
-  size_t start_;            // Frame start index.
-  size_t count_;            // Number of valid frames.
-  size_t flush_count_;      // If >0, 'flush_count' frames starting from
+  EncodedFrame* encoded_frames;       // Array of encoded frames.
+  size_t size;              // Number of allocated frames.
+  size_t start;             // Frame start index.
+  size_t count;             // Number of valid frames.
+  size_t flush_count;       // If >0, 'flush_count' frames starting from
                             // 'start' are ready to be added to mux.
 
   // key-frame related.
-  int64_t best_delta_;      // min(canvas size - frame size) over the frames.
+  int64_t best_delta;       // min(canvas size - frame size) over the frames.
                             // Can be negative in certain cases due to
                             // transparent pixels in a frame.
-  int keyframe_;            // Index of selected key-frame relative to 'start_'.
-  int count_since_key_frame_;     // Frames seen since the last key-frame.
+  int keyframe;             // Index of selected key-frame relative to 'start'.
+  int count_since_key_frame;      // Frames seen since the last key-frame.
 
-  int first_timestamp_;           // Timestamp of the first frame.
-  int prev_timestamp_;            // Timestamp of the last added frame.
-  int prev_candidate_undecided_;  // True if it's not yet decided if previous
+  int first_timestamp;            // Timestamp of the first frame.
+  int prev_timestamp;             // Timestamp of the last added frame.
+  int prev_candidate_undecided;   // True if it's not yet decided if previous
                                   // frame would be a sub-frame or a key-frame.
 
   // Misc.
-  int is_first_frame_;  // True if first frame is yet to be added/being added.
-  int got_null_frame_;  // True if WebPAnimEncoderAdd() has already been called
+  int is_first_frame;   // True if first frame is yet to be added/being added.
+  int got_null_frame;   // True if WebPAnimEncoderAdd() has already been called
                         // with a NULL frame.
 
-  size_t in_frame_count_;   // Number of input frames processed so far.
-  size_t out_frame_count_;  // Number of frames added to mux so far. This may be
-                            // different from 'in_frame_count_' due to merging.
+  size_t in_frame_count;   // Number of input frames processed so far.
+  size_t out_frame_count;  // Number of frames added to mux so far. This may be
+                           // different from 'in_frame_count' due to merging.
 
-  WebPMux* mux_;        // Muxer to assemble the WebP bitstream.
-  char error_str_[ERROR_STR_MAX_LENGTH];  // Error string. Empty if no error.
+  WebPMux* mux;         // Muxer to assemble the WebP bitstream.
+  char error_str[ERROR_STR_MAX_LENGTH];  // Error string. Empty if no error.
 };
 
 // -----------------------------------------------------------------------------
@@ -109,11 +111,11 @@ struct WebPAnimEncoder {
 
 // Reset the counters in the WebPAnimEncoder.
 static void ResetCounters(WebPAnimEncoder* const enc) {
-  enc->start_ = 0;
-  enc->count_ = 0;
-  enc->flush_count_ = 0;
-  enc->best_delta_ = DELTA_INFINITY;
-  enc->keyframe_ = KEYFRAME_NONE;
+  enc->start = 0;
+  enc->count = 0;
+  enc->flush_count = 0;
+  enc->best_delta = DELTA_INFINITY;
+  enc->keyframe = KEYFRAME_NONE;
 }
 
 static void DisableKeyframes(WebPAnimEncoderOptions* const enc_options) {
@@ -210,26 +212,26 @@ static void ClearRectangle(WebPPicture* const picture,
 static void WebPUtilClearPic(WebPPicture* const picture,
                              const FrameRectangle* const rect) {
   if (rect != NULL) {
-    ClearRectangle(picture, rect->x_offset_, rect->y_offset_,
-                   rect->width_, rect->height_);
+    ClearRectangle(picture, rect->x_offset, rect->y_offset,
+                   rect->width, rect->height);
   } else {
     ClearRectangle(picture, 0, 0, picture->width, picture->height);
   }
 }
 
 static void MarkNoError(WebPAnimEncoder* const enc) {
-  enc->error_str_[0] = '\0';  // Empty string.
+  enc->error_str[0] = '\0';  // Empty string.
 }
 
 static void MarkError(WebPAnimEncoder* const enc, const char* str) {
-  if (snprintf(enc->error_str_, ERROR_STR_MAX_LENGTH, "%s.", str) < 0) {
+  if (snprintf(enc->error_str, ERROR_STR_MAX_LENGTH, "%s.", str) < 0) {
     assert(0);  // FIX ME!
   }
 }
 
 static void MarkError2(WebPAnimEncoder* const enc,
                        const char* str, int error_code) {
-  if (snprintf(enc->error_str_, ERROR_STR_MAX_LENGTH, "%s: %d.", str,
+  if (snprintf(enc->error_str, ERROR_STR_MAX_LENGTH, "%s: %d.", str,
                error_code) < 0) {
     assert(0);  // FIX ME!
   }
@@ -253,52 +255,52 @@ WebPAnimEncoder* WebPAnimEncoderNewInternal(
   MarkNoError(enc);
 
   // Dimensions and options.
-  *(int*)&enc->canvas_width_ = width;
-  *(int*)&enc->canvas_height_ = height;
+  *(int*)&enc->canvas_width = width;
+  *(int*)&enc->canvas_height = height;
   if (enc_options != NULL) {
-    *(WebPAnimEncoderOptions*)&enc->options_ = *enc_options;
-    SanitizeEncoderOptions((WebPAnimEncoderOptions*)&enc->options_);
+    *(WebPAnimEncoderOptions*)&enc->options = *enc_options;
+    SanitizeEncoderOptions((WebPAnimEncoderOptions*)&enc->options);
   } else {
-    DefaultEncoderOptions((WebPAnimEncoderOptions*)&enc->options_);
+    DefaultEncoderOptions((WebPAnimEncoderOptions*)&enc->options);
   }
 
   // Canvas buffers.
-  if (!WebPPictureInit(&enc->curr_canvas_copy_) ||
-      !WebPPictureInit(&enc->prev_canvas_) ||
-      !WebPPictureInit(&enc->prev_canvas_disposed_)) {
+  if (!WebPPictureInit(&enc->curr_canvas_copy) ||
+      !WebPPictureInit(&enc->prev_canvas) ||
+      !WebPPictureInit(&enc->prev_canvas_disposed)) {
     goto Err;
   }
-  enc->curr_canvas_copy_.width = width;
-  enc->curr_canvas_copy_.height = height;
-  enc->curr_canvas_copy_.use_argb = 1;
-  if (!WebPPictureAlloc(&enc->curr_canvas_copy_) ||
-      !WebPPictureCopy(&enc->curr_canvas_copy_, &enc->prev_canvas_) ||
-      !WebPPictureCopy(&enc->curr_canvas_copy_, &enc->prev_canvas_disposed_)) {
+  enc->curr_canvas_copy.width = width;
+  enc->curr_canvas_copy.height = height;
+  enc->curr_canvas_copy.use_argb = 1;
+  if (!WebPPictureAlloc(&enc->curr_canvas_copy) ||
+      !WebPPictureCopy(&enc->curr_canvas_copy, &enc->prev_canvas) ||
+      !WebPPictureCopy(&enc->curr_canvas_copy, &enc->prev_canvas_disposed)) {
     goto Err;
   }
-  WebPUtilClearPic(&enc->prev_canvas_, NULL);
-  enc->curr_canvas_copy_modified_ = 1;
+  WebPUtilClearPic(&enc->prev_canvas, NULL);
+  enc->curr_canvas_copy_modified = 1;
 
   // Encoded frames.
   ResetCounters(enc);
   // Note: one extra storage is for the previous frame.
-  enc->size_ = enc->options_.kmax - enc->options_.kmin + 1;
+  enc->size = enc->options.kmax - enc->options.kmin + 1;
   // We need space for at least 2 frames. But when kmin, kmax are both zero,
-  // enc->size_ will be 1. So we handle that special case below.
-  if (enc->size_ < 2) enc->size_ = 2;
-  enc->encoded_frames_ =
-      (EncodedFrame*)WebPSafeCalloc(enc->size_, sizeof(*enc->encoded_frames_));
-  if (enc->encoded_frames_ == NULL) goto Err;
-
-  enc->mux_ = WebPMuxNew();
-  if (enc->mux_ == NULL) goto Err;
-
-  enc->count_since_key_frame_ = 0;
-  enc->first_timestamp_ = 0;
-  enc->prev_timestamp_ = 0;
-  enc->prev_candidate_undecided_ = 0;
-  enc->is_first_frame_ = 1;
-  enc->got_null_frame_ = 0;
+  // enc->size will be 1. So we handle that special case below.
+  if (enc->size < 2) enc->size = 2;
+  enc->encoded_frames =
+      (EncodedFrame*)WebPSafeCalloc(enc->size, sizeof(*enc->encoded_frames));
+  if (enc->encoded_frames == NULL) goto Err;
+
+  enc->mux = WebPMuxNew();
+  if (enc->mux == NULL) goto Err;
+
+  enc->count_since_key_frame = 0;
+  enc->first_timestamp = 0;
+  enc->prev_timestamp = 0;
+  enc->prev_candidate_undecided = 0;
+  enc->is_first_frame = 1;
+  enc->got_null_frame = 0;
 
   return enc;  // All OK.
 
@@ -310,25 +312,25 @@ WebPAnimEncoder* WebPAnimEncoderNewInternal(
 // Release the data contained by 'encoded_frame'.
 static void FrameRelease(EncodedFrame* const encoded_frame) {
   if (encoded_frame != NULL) {
-    WebPDataClear(&encoded_frame->sub_frame_.bitstream);
-    WebPDataClear(&encoded_frame->key_frame_.bitstream);
+    WebPDataClear(&encoded_frame->sub_frame.bitstream);
+    WebPDataClear(&encoded_frame->key_frame.bitstream);
     memset(encoded_frame, 0, sizeof(*encoded_frame));
   }
 }
 
 void WebPAnimEncoderDelete(WebPAnimEncoder* enc) {
   if (enc != NULL) {
-    WebPPictureFree(&enc->curr_canvas_copy_);
-    WebPPictureFree(&enc->prev_canvas_);
-    WebPPictureFree(&enc->prev_canvas_disposed_);
-    if (enc->encoded_frames_ != NULL) {
+    WebPPictureFree(&enc->curr_canvas_copy);
+    WebPPictureFree(&enc->prev_canvas);
+    WebPPictureFree(&enc->prev_canvas_disposed);
+    if (enc->encoded_frames != NULL) {
       size_t i;
-      for (i = 0; i < enc->size_; ++i) {
-        FrameRelease(&enc->encoded_frames_[i]);
+      for (i = 0; i < enc->size; ++i) {
+        FrameRelease(&enc->encoded_frames[i]);
       }
-      WebPSafeFree(enc->encoded_frames_);
+      WebPSafeFree(enc->encoded_frames);
     }
-    WebPMuxDelete(enc->mux_);
+    WebPMuxDelete(enc->mux);
     WebPSafeFree(enc);
   }
 }
@@ -339,8 +341,8 @@ void WebPAnimEncoderDelete(WebPAnimEncoder* enc) {
 // Returns cached frame at the given 'position'.
 static EncodedFrame* GetFrame(const WebPAnimEncoder* const enc,
                               size_t position) {
-  assert(enc->start_ + position < enc->size_);
-  return &enc->encoded_frames_[enc->start_ + position];
+  assert(enc->start + position < enc->size);
+  return &enc->encoded_frames[enc->start + position];
 }
 
 typedef int (*ComparePixelsFunc)(const uint32_t*, int, const uint32_t*, int,
@@ -400,7 +402,7 @@ static WEBP_INLINE int ComparePixelsLossy(const uint32_t* src, int src_step,
 }
 
 static int IsEmptyRect(const FrameRectangle* const rect) {
-  return (rect->width_ == 0) || (rect->height_ == 0);
+  return (rect->width == 0) || (rect->height == 0);
 }
 
 static int QualityToMaxDiff(float quality) {
@@ -422,113 +424,113 @@ static void MinimizeChangeRectangle(const WebPPicture* const src,
 
   // Assumption/correctness checks.
   assert(src->width == dst->width && src->height == dst->height);
-  assert(rect->x_offset_ + rect->width_ <= dst->width);
-  assert(rect->y_offset_ + rect->height_ <= dst->height);
+  assert(rect->x_offset + rect->width <= dst->width);
+  assert(rect->y_offset + rect->height <= dst->height);
 
   // Left boundary.
-  for (i = rect->x_offset_; i < rect->x_offset_ + rect->width_; ++i) {
+  for (i = rect->x_offset; i < rect->x_offset + rect->width; ++i) {
     const uint32_t* const src_argb =
-        &src->argb[rect->y_offset_ * src->argb_stride + i];
+        &src->argb[rect->y_offset * src->argb_stride + i];
     const uint32_t* const dst_argb =
-        &dst->argb[rect->y_offset_ * dst->argb_stride + i];
+        &dst->argb[rect->y_offset * dst->argb_stride + i];
     if (compare_pixels(src_argb, src->argb_stride, dst_argb, dst->argb_stride,
-                       rect->height_, max_allowed_diff)) {
-      --rect->width_;  // Redundant column.
-      ++rect->x_offset_;
+                       rect->height, max_allowed_diff)) {
+      --rect->width;  // Redundant column.
+      ++rect->x_offset;
     } else {
       break;
     }
   }
-  if (rect->width_ == 0) goto NoChange;
+  if (rect->width == 0) goto NoChange;
 
   // Right boundary.
-  for (i = rect->x_offset_ + rect->width_ - 1; i >= rect->x_offset_; --i) {
+  for (i = rect->x_offset + rect->width - 1; i >= rect->x_offset; --i) {
     const uint32_t* const src_argb =
-        &src->argb[rect->y_offset_ * src->argb_stride + i];
+        &src->argb[rect->y_offset * src->argb_stride + i];
     const uint32_t* const dst_argb =
-        &dst->argb[rect->y_offset_ * dst->argb_stride + i];
+        &dst->argb[rect->y_offset * dst->argb_stride + i];
     if (compare_pixels(src_argb, src->argb_stride, dst_argb, dst->argb_stride,
-                       rect->height_, max_allowed_diff)) {
-      --rect->width_;  // Redundant column.
+                       rect->height, max_allowed_diff)) {
+      --rect->width;  // Redundant column.
     } else {
       break;
     }
   }
-  if (rect->width_ == 0) goto NoChange;
+  if (rect->width == 0) goto NoChange;
 
   // Top boundary.
-  for (j = rect->y_offset_; j < rect->y_offset_ + rect->height_; ++j) {
+  for (j = rect->y_offset; j < rect->y_offset + rect->height; ++j) {
     const uint32_t* const src_argb =
-        &src->argb[j * src->argb_stride + rect->x_offset_];
+        &src->argb[j * src->argb_stride + rect->x_offset];
     const uint32_t* const dst_argb =
-        &dst->argb[j * dst->argb_stride + rect->x_offset_];
-    if (compare_pixels(src_argb, 1, dst_argb, 1, rect->width_,
+        &dst->argb[j * dst->argb_stride + rect->x_offset];
+    if (compare_pixels(src_argb, 1, dst_argb, 1, rect->width,
                        max_allowed_diff)) {
-      --rect->height_;  // Redundant row.
-      ++rect->y_offset_;
+      --rect->height;  // Redundant row.
+      ++rect->y_offset;
     } else {
       break;
     }
   }
-  if (rect->height_ == 0) goto NoChange;
+  if (rect->height == 0) goto NoChange;
 
   // Bottom boundary.
-  for (j = rect->y_offset_ + rect->height_ - 1; j >= rect->y_offset_; --j) {
+  for (j = rect->y_offset + rect->height - 1; j >= rect->y_offset; --j) {
     const uint32_t* const src_argb =
-        &src->argb[j * src->argb_stride + rect->x_offset_];
+        &src->argb[j * src->argb_stride + rect->x_offset];
     const uint32_t* const dst_argb =
-        &dst->argb[j * dst->argb_stride + rect->x_offset_];
-    if (compare_pixels(src_argb, 1, dst_argb, 1, rect->width_,
+        &dst->argb[j * dst->argb_stride + rect->x_offset];
+    if (compare_pixels(src_argb, 1, dst_argb, 1, rect->width,
                        max_allowed_diff)) {
-      --rect->height_;  // Redundant row.
+      --rect->height;  // Redundant row.
     } else {
       break;
     }
   }
-  if (rect->height_ == 0) goto NoChange;
+  if (rect->height == 0) goto NoChange;
 
   if (IsEmptyRect(rect)) {
  NoChange:
-    rect->x_offset_ = 0;
-    rect->y_offset_ = 0;
-    rect->width_ = 0;
-    rect->height_ = 0;
+    rect->x_offset = 0;
+    rect->y_offset = 0;
+    rect->width = 0;
+    rect->height = 0;
   }
 }
 
 // Snap rectangle to even offsets (and adjust dimensions if needed).
 static WEBP_INLINE void SnapToEvenOffsets(FrameRectangle* const rect) {
-  rect->width_ += (rect->x_offset_ & 1);
-  rect->height_ += (rect->y_offset_ & 1);
-  rect->x_offset_ &= ~1;
-  rect->y_offset_ &= ~1;
+  rect->width += (rect->x_offset & 1);
+  rect->height += (rect->y_offset & 1);
+  rect->x_offset &= ~1;
+  rect->y_offset &= ~1;
 }
 
 typedef struct {
-  int should_try_;               // Should try this set of parameters.
-  int empty_rect_allowed_;       // Frame with empty rectangle can be skipped.
-  FrameRectangle rect_ll_;       // Frame rectangle for lossless compression.
-  WebPPicture sub_frame_ll_;     // Sub-frame pic for lossless compression.
-  FrameRectangle rect_lossy_;    // Frame rectangle for lossy compression.
-                                 // Could be smaller than rect_ll_ as pixels
+  int should_try;                // Should try this set of parameters.
+  int empty_rect_allowed;        // Frame with empty rectangle can be skipped.
+  FrameRectangle rect_ll;        // Frame rectangle for lossless compression.
+  WebPPicture sub_frame_ll;      // Sub-frame pic for lossless compression.
+  FrameRectangle rect_lossy;     // Frame rectangle for lossy compression.
+                                 // Could be smaller than 'rect_ll' as pixels
                                  // 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.
 } SubFrameParams;
 
 static int SubFrameParamsInit(SubFrameParams* const params,
                               int should_try, int empty_rect_allowed) {
-  params->should_try_ = should_try;
-  params->empty_rect_allowed_ = empty_rect_allowed;
-  if (!WebPPictureInit(&params->sub_frame_ll_) ||
-      !WebPPictureInit(&params->sub_frame_lossy_)) {
+  params->should_try = should_try;
+  params->empty_rect_allowed = empty_rect_allowed;
+  if (!WebPPictureInit(&params->sub_frame_ll) ||
+      !WebPPictureInit(&params->sub_frame_lossy)) {
     return 0;
   }
   return 1;
 }
 
 static void SubFrameParamsFree(SubFrameParams* const params) {
-  WebPPictureFree(&params->sub_frame_ll_);
-  WebPPictureFree(&params->sub_frame_lossy_);
+  WebPPictureFree(&params->sub_frame_ll);
+  WebPPictureFree(&params->sub_frame_lossy);
 }
 
 // Given previous and current canvas, picks the optimal rectangle for the
@@ -551,16 +553,16 @@ static int GetSubRect(const WebPPicture* const prev_canvas,
     if (empty_rect_allowed) {  // No need to get 'sub_frame'.
       return 1;
     } else {                   // Force a 1x1 rectangle.
-      rect->width_ = 1;
-      rect->height_ = 1;
-      assert(rect->x_offset_ == 0);
-      assert(rect->y_offset_ == 0);
+      rect->width = 1;
+      rect->height = 1;
+      assert(rect->x_offset == 0);
+      assert(rect->y_offset == 0);
     }
   }
 
   SnapToEvenOffsets(rect);
-  return WebPPictureView(curr_canvas, rect->x_offset_, rect->y_offset_,
-                         rect->width_, rect->height_, sub_frame);
+  return WebPPictureView(curr_canvas, rect->x_offset, rect->y_offset,
+                         rect->width, rect->height, sub_frame);
 }
 
 // Picks optimal frame rectangle for both lossless and lossy compression. The
@@ -570,20 +572,20 @@ static int GetSubRects(const WebPPicture* const prev_canvas,
                        int is_first_frame, float quality,
                        SubFrameParams* const params) {
   // Lossless frame rectangle.
-  params->rect_ll_.x_offset_ = 0;
-  params->rect_ll_.y_offset_ = 0;
-  params->rect_ll_.width_ = curr_canvas->width;
-  params->rect_ll_.height_ = curr_canvas->height;
+  params->rect_ll.x_offset = 0;
+  params->rect_ll.y_offset = 0;
+  params->rect_ll.width = curr_canvas->width;
+  params->rect_ll.height = curr_canvas->height;
   if (!GetSubRect(prev_canvas, curr_canvas, is_key_frame, is_first_frame,
-                  params->empty_rect_allowed_, 1, quality,
-                  &params->rect_ll_, &params->sub_frame_ll_)) {
+                  params->empty_rect_allowed, 1, quality,
+                  &params->rect_ll, &params->sub_frame_ll)) {
     return 0;
   }
   // Lossy frame rectangle.
-  params->rect_lossy_ = params->rect_ll_;  // seed with lossless rect.
+  params->rect_lossy = params->rect_ll;  // seed with lossless rect.
   return GetSubRect(prev_canvas, curr_canvas, is_key_frame, is_first_frame,
-                    params->empty_rect_allowed_, 0, quality,
-                    &params->rect_lossy_, &params->sub_frame_lossy_);
+                    params->empty_rect_allowed, 0, quality,
+                    &params->rect_lossy, &params->sub_frame_lossy);
 }
 
 static WEBP_INLINE int clip(int v, int min_v, int max_v) {
@@ -606,17 +608,17 @@ int WebPAnimEncoderRefineRect(
   left = clip(*x_offset, 0, curr_canvas->width - 1);
   bottom = clip(*y_offset + *height, 0, curr_canvas->height);
   top = clip(*y_offset, 0, curr_canvas->height - 1);
-  rect.x_offset_ = left;
-  rect.y_offset_ = top;
-  rect.width_ = clip(right - left, 0, curr_canvas->width - rect.x_offset_);
-  rect.height_ = clip(bottom - top, 0, curr_canvas->height - rect.y_offset_);
+  rect.x_offset = left;
+  rect.y_offset = top;
+  rect.width = clip(right - left, 0, curr_canvas->width - rect.x_offset);
+  rect.height = clip(bottom - top, 0, curr_canvas->height - rect.y_offset);
   MinimizeChangeRectangle(prev_canvas, curr_canvas, &rect, is_lossless,
                           quality);
   SnapToEvenOffsets(&rect);
-  *x_offset = rect.x_offset_;
-  *y_offset = rect.y_offset_;
-  *width = rect.width_;
-  *height = rect.height_;
+  *x_offset = rect.x_offset;
+  *y_offset = rect.y_offset;
+  *width = rect.width;
+  *height = rect.height;
   return 1;
 }
 
@@ -630,7 +632,7 @@ static void DisposeFrameRectangle(int dispose_method,
 }
 
 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,
@@ -638,10 +640,10 @@ static int IsLosslessBlendingPossible(const WebPPicture* const src,
                                       const FrameRectangle* const rect) {
   int i, j;
   assert(src->width == dst->width && src->height == dst->height);
-  assert(rect->x_offset_ + rect->width_ <= dst->width);
-  assert(rect->y_offset_ + rect->height_ <= dst->height);
-  for (j = rect->y_offset_; j < rect->y_offset_ + rect->height_; ++j) {
-    for (i = rect->x_offset_; i < rect->x_offset_ + rect->width_; ++i) {
+  assert(rect->x_offset + rect->width <= dst->width);
+  assert(rect->y_offset + rect->height <= dst->height);
+  for (j = rect->y_offset; j < rect->y_offset + rect->height; ++j) {
+    for (i = rect->x_offset; i < rect->x_offset + rect->width; ++i) {
       const uint32_t src_pixel = src->argb[j * src->argb_stride + i];
       const uint32_t dst_pixel = dst->argb[j * dst->argb_stride + i];
       const uint32_t dst_alpha = dst_pixel >> 24;
@@ -662,10 +664,10 @@ static int IsLossyBlendingPossible(const WebPPicture* const src,
   const int max_allowed_diff_lossy = QualityToMaxDiff(quality);
   int i, j;
   assert(src->width == dst->width && src->height == dst->height);
-  assert(rect->x_offset_ + rect->width_ <= dst->width);
-  assert(rect->y_offset_ + rect->height_ <= dst->height);
-  for (j = rect->y_offset_; j < rect->y_offset_ + rect->height_; ++j) {
-    for (i = rect->x_offset_; i < rect->x_offset_ + rect->width_; ++i) {
+  assert(rect->x_offset + rect->width <= dst->width);
+  assert(rect->y_offset + rect->height <= dst->height);
+  for (j = rect->y_offset; j < rect->y_offset + rect->height; ++j) {
+    for (i = rect->x_offset; i < rect->x_offset + rect->width; ++i) {
       const uint32_t src_pixel = src->argb[j * src->argb_stride + i];
       const uint32_t dst_pixel = dst->argb[j * dst->argb_stride + i];
       const uint32_t dst_alpha = dst_pixel >> 24;
@@ -690,10 +692,10 @@ static int IncreaseTransparency(const WebPPicture* const src,
   int modified = 0;
   assert(src != NULL && dst != NULL && rect != NULL);
   assert(src->width == dst->width && src->height == dst->height);
-  for (j = rect->y_offset_; j < rect->y_offset_ + rect->height_; ++j) {
+  for (j = rect->y_offset; j < rect->y_offset + rect->height; ++j) {
     const uint32_t* const psrc = src->argb + j * src->argb_stride;
     uint32_t* const pdst = dst->argb + j * dst->argb_stride;
-    for (i = rect->x_offset_; i < rect->x_offset_ + rect->width_; ++i) {
+    for (i = rect->x_offset; i < rect->x_offset + rect->width; ++i) {
       if (psrc[i] == pdst[i] && pdst[i] != TRANSPARENT_COLOR) {
         pdst[i] = TRANSPARENT_COLOR;
         modified = 1;
@@ -716,10 +718,10 @@ static int FlattenSimilarBlocks(const WebPPicture* const src,
   int i, j;
   int modified = 0;
   const int block_size = 8;
-  const int y_start = (rect->y_offset_ + block_size) & ~(block_size - 1);
-  const int y_end = (rect->y_offset_ + rect->height_) & ~(block_size - 1);
-  const int x_start = (rect->x_offset_ + block_size) & ~(block_size - 1);
-  const int x_end = (rect->x_offset_ + rect->width_) & ~(block_size - 1);
+  const int y_start = (rect->y_offset + block_size) & ~(block_size - 1);
+  const int y_end = (rect->y_offset + rect->height) & ~(block_size - 1);
+  const int x_start = (rect->x_offset + block_size) & ~(block_size - 1);
+  const int x_end = (rect->x_offset + rect->width) & ~(block_size - 1);
   assert(src != NULL && dst != NULL && rect != NULL);
   assert(src->width == dst->width && src->height == dst->height);
   assert((block_size & (block_size - 1)) == 0);  // must be a power of 2
@@ -777,10 +779,10 @@ static int EncodeFrame(const WebPConfig* const config, WebPPicture* const pic,
 
 // Struct representing a candidate encoded frame including its metadata.
 typedef struct {
-  WebPMemoryWriter  mem_;
-  WebPMuxFrameInfo  info_;
-  FrameRectangle    rect_;
-  int               evaluate_;  // True if this candidate should be evaluated.
+  WebPMemoryWriter  mem;
+  WebPMuxFrameInfo  info;
+  FrameRectangle    rect;
+  int               evaluate;  // True if this candidate should be evaluated.
 } Candidate;
 
 // Generates a candidate encoded frame given a picture and metadata.
@@ -795,17 +797,17 @@ static WebPEncodingError EncodeCandidate(WebPPicture* const sub_frame,
   memset(candidate, 0, sizeof(*candidate));
 
   // Set frame rect and info.
-  candidate->rect_ = *rect;
-  candidate->info_.id = WEBP_CHUNK_ANMF;
-  candidate->info_.x_offset = rect->x_offset_;
-  candidate->info_.y_offset = rect->y_offset_;
-  candidate->info_.dispose_method = WEBP_MUX_DISPOSE_NONE;  // Set later.
-  candidate->info_.blend_method =
+  candidate->rect = *rect;
+  candidate->info.id = WEBP_CHUNK_ANMF;
+  candidate->info.x_offset = rect->x_offset;
+  candidate->info.y_offset = rect->y_offset;
+  candidate->info.dispose_method = WEBP_MUX_DISPOSE_NONE;  // Set later.
+  candidate->info.blend_method =
       use_blending ? WEBP_MUX_BLEND : WEBP_MUX_NO_BLEND;
-  candidate->info_.duration = 0;  // Set in next call to WebPAnimEncoderAdd().
+  candidate->info.duration = 0;  // Set in next call to WebPAnimEncoderAdd().
 
   // Encode picture.
-  WebPMemoryWriterInit(&candidate->mem_);
+  WebPMemoryWriterInit(&candidate->mem);
 
   if (!config.lossless && use_blending) {
     // Disable filtering to avoid blockiness in reconstructed frames at the
@@ -813,25 +815,25 @@ static WebPEncodingError EncodeCandidate(WebPPicture* const sub_frame,
     config.autofilter = 0;
     config.filter_strength = 0;
   }
-  if (!EncodeFrame(&config, sub_frame, &candidate->mem_)) {
+  if (!EncodeFrame(&config, sub_frame, &candidate->mem)) {
     error_code = sub_frame->error_code;
     goto Err;
   }
 
-  candidate->evaluate_ = 1;
+  candidate->evaluate = 1;
   return error_code;
 
  Err:
-  WebPMemoryWriterClear(&candidate->mem_);
+  WebPMemoryWriterClear(&candidate->mem);
   return error_code;
 }
 
 static void CopyCurrentCanvas(WebPAnimEncoder* const enc) {
-  if (enc->curr_canvas_copy_modified_) {
-    WebPCopyPixels(enc->curr_canvas_, &enc->curr_canvas_copy_);
-    enc->curr_canvas_copy_.progress_hook = enc->curr_canvas_->progress_hook;
-    enc->curr_canvas_copy_.user_data = enc->curr_canvas_->user_data;
-    enc->curr_canvas_copy_modified_ = 0;
+  if (enc->curr_canvas_copy_modified) {
+    WebPCopyPixels(enc->curr_canvas, &enc->curr_canvas_copy);
+    enc->curr_canvas_copy.progress_hook = enc->curr_canvas->progress_hook;
+    enc->curr_canvas_copy.user_data = enc->curr_canvas->user_data;
+    enc->curr_canvas_copy_modified = 0;
   }
 }
 
@@ -860,30 +862,30 @@ static WebPEncodingError GenerateCandidates(
   Candidate* const candidate_lossy = is_dispose_none
                                      ? &candidates[LOSSY_DISP_NONE]
                                      : &candidates[LOSSY_DISP_BG];
-  WebPPicture* const curr_canvas = &enc->curr_canvas_copy_;
+  WebPPicture* const curr_canvas = &enc->curr_canvas_copy;
   const WebPPicture* const prev_canvas =
-      is_dispose_none ? &enc->prev_canvas_ : &enc->prev_canvas_disposed_;
+      is_dispose_none ? &enc->prev_canvas : &enc->prev_canvas_disposed;
   int use_blending_ll, use_blending_lossy;
   int evaluate_ll, evaluate_lossy;
 
   CopyCurrentCanvas(enc);
   use_blending_ll =
       !is_key_frame &&
-      IsLosslessBlendingPossible(prev_canvas, curr_canvas, &params->rect_ll_);
+      IsLosslessBlendingPossible(prev_canvas, curr_canvas, &params->rect_ll);
   use_blending_lossy =
       !is_key_frame &&
-      IsLossyBlendingPossible(prev_canvas, curr_canvas, &params->rect_lossy_,
+      IsLossyBlendingPossible(prev_canvas, curr_canvas, &params->rect_lossy,
                               config_lossy->quality);
 
   // Pick candidates to be tried.
-  if (!enc->options_.allow_mixed) {
+  if (!enc->options.allow_mixed) {
     evaluate_ll = is_lossless;
     evaluate_lossy = !is_lossless;
-  } else if (enc->options_.minimize_size) {
+  } else if (enc->options.minimize_size) {
     evaluate_ll = 1;
     evaluate_lossy = 1;
   } else {  // Use a heuristic for trying lossless and/or lossy compression.
-    const int num_colors = WebPGetColorPalette(&params->sub_frame_ll_, NULL);
+    const int num_colors = WebPGetColorPalette(&params->sub_frame_ll, NULL);
     evaluate_ll = (num_colors < MAX_COLORS_LOSSLESS);
     evaluate_lossy = (num_colors >= MIN_COLORS_LOSSY);
   }
@@ -892,25 +894,25 @@ static WebPEncodingError GenerateCandidates(
   if (evaluate_ll) {
     CopyCurrentCanvas(enc);
     if (use_blending_ll) {
-      enc->curr_canvas_copy_modified_ =
-          IncreaseTransparency(prev_canvas, &params->rect_ll_, curr_canvas);
+      enc->curr_canvas_copy_modified =
+          IncreaseTransparency(prev_canvas, &params->rect_ll, curr_canvas);
     }
-    error_code = EncodeCandidate(&params->sub_frame_ll_, &params->rect_ll_,
+    error_code = EncodeCandidate(&params->sub_frame_ll, &params->rect_ll,
                                  config_ll, use_blending_ll, candidate_ll);
     if (error_code != VP8_ENC_OK) return error_code;
   }
   if (evaluate_lossy) {
     CopyCurrentCanvas(enc);
     if (use_blending_lossy) {
-      enc->curr_canvas_copy_modified_ =
-          FlattenSimilarBlocks(prev_canvas, &params->rect_lossy_, curr_canvas,
+      enc->curr_canvas_copy_modified =
+          FlattenSimilarBlocks(prev_canvas, &params->rect_lossy, curr_canvas,
                                config_lossy->quality);
     }
     error_code =
-        EncodeCandidate(&params->sub_frame_lossy_, &params->rect_lossy_,
+        EncodeCandidate(&params->sub_frame_lossy, &params->rect_lossy,
                         config_lossy, use_blending_lossy, candidate_lossy);
     if (error_code != VP8_ENC_OK) return error_code;
-    enc->curr_canvas_copy_modified_ = 1;
+    enc->curr_canvas_copy_modified = 1;
   }
   return error_code;
 }
@@ -927,36 +929,36 @@ static void GetEncodedData(const WebPMemoryWriter* const memory,
 // Sets dispose method of the previous frame to be 'dispose_method'.
 static void SetPreviousDisposeMethod(WebPAnimEncoder* const enc,
                                      WebPMuxAnimDispose dispose_method) {
-  const size_t position = enc->count_ - 2;
+  const size_t position = enc->count - 2;
   EncodedFrame* const prev_enc_frame = GetFrame(enc, position);
-  assert(enc->count_ >= 2);  // As current and previous frames are in enc.
+  assert(enc->count >= 2);  // As current and previous frames are in enc.
 
-  if (enc->prev_candidate_undecided_) {
+  if (enc->prev_candidate_undecided) {
     assert(dispose_method == WEBP_MUX_DISPOSE_NONE);
-    prev_enc_frame->sub_frame_.dispose_method = dispose_method;
-    prev_enc_frame->key_frame_.dispose_method = dispose_method;
+    prev_enc_frame->sub_frame.dispose_method = dispose_method;
+    prev_enc_frame->key_frame.dispose_method = dispose_method;
   } else {
-    WebPMuxFrameInfo* const prev_info = prev_enc_frame->is_key_frame_
-                                        ? &prev_enc_frame->key_frame_
-                                        : &prev_enc_frame->sub_frame_;
+    WebPMuxFrameInfo* const prev_info = prev_enc_frame->is_key_frame
+                                        ? &prev_enc_frame->key_frame
+                                        : &prev_enc_frame->sub_frame;
     prev_info->dispose_method = dispose_method;
   }
 }
 
 static int IncreasePreviousDuration(WebPAnimEncoder* const enc, int duration) {
-  const size_t position = enc->count_ - 1;
+  const size_t position = enc->count - 1;
   EncodedFrame* const prev_enc_frame = GetFrame(enc, position);
   int new_duration;
 
-  assert(enc->count_ >= 1);
-  assert(!prev_enc_frame->is_key_frame_ ||
-         prev_enc_frame->sub_frame_.duration ==
-         prev_enc_frame->key_frame_.duration);
-  assert(prev_enc_frame->sub_frame_.duration ==
-         (prev_enc_frame->sub_frame_.duration & (MAX_DURATION - 1)));
+  assert(enc->count >= 1);
+  assert(!prev_enc_frame->is_key_frame ||
+         prev_enc_frame->sub_frame.duration ==
+         prev_enc_frame->key_frame.duration);
+  assert(prev_enc_frame->sub_frame.duration ==
+         (prev_enc_frame->sub_frame.duration & (MAX_DURATION - 1)));
   assert(duration == (duration & (MAX_DURATION - 1)));
 
-  new_duration = prev_enc_frame->sub_frame_.duration + duration;
+  new_duration = prev_enc_frame->sub_frame.duration + duration;
   if (new_duration >= MAX_DURATION) {  // Special case.
     // Separate out previous frame from earlier merged frames to avoid overflow.
     // We add a 1x1 transparent frame for the previous frame, with blending on.
@@ -979,28 +981,28 @@ static int IncreasePreviousDuration(WebPAnimEncoder* const enc, int duration) {
     };
     const WebPData lossy_1x1 = { lossy_1x1_bytes, sizeof(lossy_1x1_bytes) };
     const int can_use_lossless =
-        (enc->last_config_.lossless || enc->options_.allow_mixed);
-    EncodedFrame* const curr_enc_frame = GetFrame(enc, enc->count_);
-    curr_enc_frame->is_key_frame_ = 0;
-    curr_enc_frame->sub_frame_.id = WEBP_CHUNK_ANMF;
-    curr_enc_frame->sub_frame_.x_offset = 0;
-    curr_enc_frame->sub_frame_.y_offset = 0;
-    curr_enc_frame->sub_frame_.dispose_method = WEBP_MUX_DISPOSE_NONE;
-    curr_enc_frame->sub_frame_.blend_method = WEBP_MUX_BLEND;
-    curr_enc_frame->sub_frame_.duration = duration;
+        (enc->last_config.lossless || enc->options.allow_mixed);
+    EncodedFrame* const curr_enc_frame = GetFrame(enc, enc->count);
+    curr_enc_frame->is_key_frame = 0;
+    curr_enc_frame->sub_frame.id = WEBP_CHUNK_ANMF;
+    curr_enc_frame->sub_frame.x_offset = 0;
+    curr_enc_frame->sub_frame.y_offset = 0;
+    curr_enc_frame->sub_frame.dispose_method = WEBP_MUX_DISPOSE_NONE;
+    curr_enc_frame->sub_frame.blend_method = WEBP_MUX_BLEND;
+    curr_enc_frame->sub_frame.duration = duration;
     if (!WebPDataCopy(can_use_lossless ? &lossless_1x1 : &lossy_1x1,
-                      &curr_enc_frame->sub_frame_.bitstream)) {
+                      &curr_enc_frame->sub_frame.bitstream)) {
       return 0;
     }
-    ++enc->count_;
-    ++enc->count_since_key_frame_;
-    enc->flush_count_ = enc->count_ - 1;
-    enc->prev_candidate_undecided_ = 0;
-    enc->prev_rect_ = rect;
+    ++enc->count;
+    ++enc->count_since_key_frame;
+    enc->flush_count = enc->count - 1;
+    enc->prev_candidate_undecided = 0;
+    enc->prev_rect = rect;
   } else {                           // Regular case.
     // Increase duration of the previous frame by 'duration'.
-    prev_enc_frame->sub_frame_.duration = new_duration;
-    prev_enc_frame->key_frame_.duration = new_duration;
+    prev_enc_frame->sub_frame.duration = new_duration;
+    prev_enc_frame->key_frame.duration = new_duration;
   }
   return 1;
 }
@@ -1016,8 +1018,8 @@ static void PickBestCandidate(WebPAnimEncoder* const enc,
   int best_idx = -1;
   size_t best_size = ~0;
   for (i = 0; i < CANDIDATE_COUNT; ++i) {
-    if (candidates[i].evaluate_) {
-      const size_t candidate_size = candidates[i].mem_.size;
+    if (candidates[i].evaluate) {
+      const size_t candidate_size = candidates[i].mem.size;
       if (candidate_size < best_size) {
         best_idx = i;
         best_size = candidate_size;
@@ -1026,13 +1028,13 @@ static void PickBestCandidate(WebPAnimEncoder* const enc,
   }
   assert(best_idx != -1);
   for (i = 0; i < CANDIDATE_COUNT; ++i) {
-    if (candidates[i].evaluate_) {
+    if (candidates[i].evaluate) {
       if (i == best_idx) {
         WebPMuxFrameInfo* const dst = is_key_frame
-                                      ? &encoded_frame->key_frame_
-                                      : &encoded_frame->sub_frame_;
-        *dst = candidates[i].info_;
-        GetEncodedData(&candidates[i].mem_, &dst->bitstream);
+                                      ? &encoded_frame->key_frame
+                                      : &encoded_frame->sub_frame;
+        *dst = candidates[i].info;
+        GetEncodedData(&candidates[i].mem, &dst->bitstream);
         if (!is_key_frame) {
           // Note: Previous dispose method only matters for non-keyframes.
           // Also, we don't want to modify previous dispose method that was
@@ -1043,10 +1045,10 @@ static void PickBestCandidate(WebPAnimEncoder* const enc,
                   : WEBP_MUX_DISPOSE_BACKGROUND;
           SetPreviousDisposeMethod(enc, prev_dispose_method);
         }
-        enc->prev_rect_ = candidates[i].rect_;  // save for next frame.
+        enc->prev_rect = candidates[i].rect;  // save for next frame.
       } else {
-        WebPMemoryWriterClear(&candidates[i].mem_);
-        candidates[i].evaluate_ = 0;
+        WebPMemoryWriterClear(&candidates[i].mem);
+        candidates[i].evaluate = 0;
       }
     }
   }
@@ -1063,13 +1065,13 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
                                   int* const frame_skipped) {
   int i;
   WebPEncodingError error_code = VP8_ENC_OK;
-  const WebPPicture* const curr_canvas = &enc->curr_canvas_copy_;
-  const WebPPicture* const prev_canvas = &enc->prev_canvas_;
+  const WebPPicture* const curr_canvas = &enc->curr_canvas_copy;
+  const WebPPicture* const prev_canvas = &enc->prev_canvas;
   Candidate candidates[CANDIDATE_COUNT];
   const int is_lossless = config->lossless;
-  const int consider_lossless = is_lossless || enc->options_.allow_mixed;
-  const int consider_lossy = !is_lossless || enc->options_.allow_mixed;
-  const int is_first_frame = enc->is_first_frame_;
+  const int consider_lossless = is_lossless || enc->options.allow_mixed;
+  const int consider_lossy = !is_lossless || enc->options.allow_mixed;
+  const int is_first_frame = enc->is_first_frame;
 
   // First frame cannot be skipped as there is no 'previous frame' to merge it
   // to. So, empty rectangle is not allowed for the first frame.
@@ -1088,7 +1090,7 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
   // rectangle would be disposed. In that case too, we don't try dispose to
   // background.
   const int dispose_bg_possible =
-      !is_key_frame && !enc->prev_candidate_undecided_;
+      !is_key_frame && !enc->prev_candidate_undecided;
 
   SubFrameParams dispose_none_params;
   SubFrameParams dispose_bg_params;
@@ -1097,8 +1099,8 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
   WebPConfig config_lossy = *config;
   config_ll.lossless = 1;
   config_lossy.lossless = 0;
-  enc->last_config_ = *config;
-  enc->last_config_reversed_ = config->lossless ? config_lossy : config_ll;
+  enc->last_config = *config;
+  enc->last_config_reversed = config->lossless ? config_lossy : config_ll;
   *frame_skipped = 0;
 
   if (!SubFrameParamsInit(&dispose_none_params, 1, empty_rect_allowed_none) ||
@@ -1115,8 +1117,8 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
     goto Err;
   }
 
-  if ((consider_lossless && IsEmptyRect(&dispose_none_params.rect_ll_)) ||
-      (consider_lossy && IsEmptyRect(&dispose_none_params.rect_lossy_))) {
+  if ((consider_lossless && IsEmptyRect(&dispose_none_params.rect_ll)) ||
+      (consider_lossy && IsEmptyRect(&dispose_none_params.rect_lossy))) {
     // Don't encode the frame at all. Instead, the duration of the previous
     // frame will be increased later.
     assert(empty_rect_allowed_none);
@@ -1126,9 +1128,9 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
 
   if (dispose_bg_possible) {
     // Change-rectangle assuming previous frame was DISPOSE_BACKGROUND.
-    WebPPicture* const prev_canvas_disposed = &enc->prev_canvas_disposed_;
+    WebPPicture* const prev_canvas_disposed = &enc->prev_canvas_disposed;
     WebPCopyPixels(prev_canvas, prev_canvas_disposed);
-    DisposeFrameRectangle(WEBP_MUX_DISPOSE_BACKGROUND, &enc->prev_rect_,
+    DisposeFrameRectangle(WEBP_MUX_DISPOSE_BACKGROUND, &enc->prev_rect,
                           prev_canvas_disposed);
 
     if (!GetSubRects(prev_canvas_disposed, curr_canvas, is_key_frame,
@@ -1137,32 +1139,32 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
       error_code = VP8_ENC_ERROR_INVALID_CONFIGURATION;
       goto Err;
     }
-    assert(!IsEmptyRect(&dispose_bg_params.rect_ll_));
-    assert(!IsEmptyRect(&dispose_bg_params.rect_lossy_));
+    assert(!IsEmptyRect(&dispose_bg_params.rect_ll));
+    assert(!IsEmptyRect(&dispose_bg_params.rect_lossy));
 
-    if (enc->options_.minimize_size) {  // Try both dispose methods.
-      dispose_bg_params.should_try_ = 1;
-      dispose_none_params.should_try_ = 1;
+    if (enc->options.minimize_size) {  // Try both dispose methods.
+      dispose_bg_params.should_try = 1;
+      dispose_none_params.should_try = 1;
     } else if ((is_lossless &&
-                RectArea(&dispose_bg_params.rect_ll_) <
-                    RectArea(&dispose_none_params.rect_ll_)) ||
+                RectArea(&dispose_bg_params.rect_ll) <
+                    RectArea(&dispose_none_params.rect_ll)) ||
                (!is_lossless &&
-                RectArea(&dispose_bg_params.rect_lossy_) <
-                    RectArea(&dispose_none_params.rect_lossy_))) {
-      dispose_bg_params.should_try_ = 1;  // Pick DISPOSE_BACKGROUND.
-      dispose_none_params.should_try_ = 0;
+                RectArea(&dispose_bg_params.rect_lossy) <
+                    RectArea(&dispose_none_params.rect_lossy))) {
+      dispose_bg_params.should_try = 1;  // Pick DISPOSE_BACKGROUND.
+      dispose_none_params.should_try = 0;
     }
   }
 
-  if (dispose_none_params.should_try_) {
+  if (dispose_none_params.should_try) {
     error_code = GenerateCandidates(
         enc, candidates, WEBP_MUX_DISPOSE_NONE, is_lossless, is_key_frame,
         &dispose_none_params, &config_ll, &config_lossy);
     if (error_code != VP8_ENC_OK) goto Err;
   }
 
-  if (dispose_bg_params.should_try_) {
-    assert(!enc->is_first_frame_);
+  if (dispose_bg_params.should_try) {
+    assert(!enc->is_first_frame);
     assert(dispose_bg_possible);
     error_code = GenerateCandidates(
         enc, candidates, WEBP_MUX_DISPOSE_BACKGROUND, is_lossless, is_key_frame,
@@ -1176,8 +1178,8 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
 
  Err:
   for (i = 0; i < CANDIDATE_COUNT; ++i) {
-    if (candidates[i].evaluate_) {
-      WebPMemoryWriterClear(&candidates[i].mem_);
+    if (candidates[i].evaluate) {
+      WebPMemoryWriterClear(&candidates[i].mem);
     }
   }
 
@@ -1190,8 +1192,8 @@ static WebPEncodingError SetFrame(WebPAnimEncoder* const enc,
 // Calculate the penalty incurred if we encode given frame as a key frame
 // instead of a sub-frame.
 static int64_t KeyFramePenalty(const EncodedFrame* const encoded_frame) {
-  return ((int64_t)encoded_frame->key_frame_.bitstream.size -
-          encoded_frame->sub_frame_.bitstream.size);
+  return ((int64_t)encoded_frame->key_frame.bitstream.size -
+          encoded_frame->sub_frame.bitstream.size);
 }
 
 static int CacheFrame(WebPAnimEncoder* const enc,
@@ -1199,30 +1201,30 @@ static int CacheFrame(WebPAnimEncoder* const enc,
   int ok = 0;
   int frame_skipped = 0;
   WebPEncodingError error_code = VP8_ENC_OK;
-  const size_t position = enc->count_;
+  const size_t position = enc->count;
   EncodedFrame* const encoded_frame = GetFrame(enc, position);
 
-  ++enc->count_;
+  ++enc->count;
 
-  if (enc->is_first_frame_) {  // Add this as a key-frame.
+  if (enc->is_first_frame) {  // Add this as a key-frame.
     error_code = SetFrame(enc, config, 1, encoded_frame, &frame_skipped);
     if (error_code != VP8_ENC_OK) goto End;
     assert(frame_skipped == 0);  // First frame can't be skipped, even if empty.
-    assert(position == 0 && enc->count_ == 1);
-    encoded_frame->is_key_frame_ = 1;
-    enc->flush_count_ = 0;
-    enc->count_since_key_frame_ = 0;
-    enc->prev_candidate_undecided_ = 0;
+    assert(position == 0 && enc->count == 1);
+    encoded_frame->is_key_frame = 1;
+    enc->flush_count = 0;
+    enc->count_since_key_frame = 0;
+    enc->prev_candidate_undecided = 0;
   } else {
-    ++enc->count_since_key_frame_;
-    if (enc->count_since_key_frame_ <= enc->options_.kmin) {
+    ++enc->count_since_key_frame;
+    if (enc->count_since_key_frame <= enc->options.kmin) {
       // Add this as a frame rectangle.
       error_code = SetFrame(enc, config, 0, encoded_frame, &frame_skipped);
       if (error_code != VP8_ENC_OK) goto End;
       if (frame_skipped) goto Skip;
-      encoded_frame->is_key_frame_ = 0;
-      enc->flush_count_ = enc->count_ - 1;
-      enc->prev_candidate_undecided_ = 0;
+      encoded_frame->is_key_frame = 0;
+      enc->flush_count = enc->count - 1;
+      enc->prev_candidate_undecided = 0;
     } else {
       int64_t curr_delta;
       FrameRectangle prev_rect_key, prev_rect_sub;
@@ -1231,103 +1233,103 @@ static int CacheFrame(WebPAnimEncoder* const enc,
       error_code = SetFrame(enc, config, 0, encoded_frame, &frame_skipped);
       if (error_code != VP8_ENC_OK) goto End;
       if (frame_skipped) goto Skip;
-      prev_rect_sub = enc->prev_rect_;
+      prev_rect_sub = enc->prev_rect;
 
 
       // Add this as a key-frame to enc, too.
       error_code = SetFrame(enc, config, 1, encoded_frame, &frame_skipped);
       if (error_code != VP8_ENC_OK) goto End;
       assert(frame_skipped == 0);  // Key-frame cannot be an empty rectangle.
-      prev_rect_key = enc->prev_rect_;
+      prev_rect_key = enc->prev_rect;
 
       // Analyze size difference of the two variants.
       curr_delta = KeyFramePenalty(encoded_frame);
-      if (curr_delta <= enc->best_delta_) {  // Pick this as the key-frame.
-        if (enc->keyframe_ != KEYFRAME_NONE) {
-          EncodedFrame* const old_keyframe = GetFrame(enc, enc->keyframe_);
-          assert(old_keyframe->is_key_frame_);
-          old_keyframe->is_key_frame_ = 0;
+      if (curr_delta <= enc->best_delta) {  // Pick this as the key-frame.
+        if (enc->keyframe != KEYFRAME_NONE) {
+          EncodedFrame* const old_keyframe = GetFrame(enc, enc->keyframe);
+          assert(old_keyframe->is_key_frame);
+          old_keyframe->is_key_frame = 0;
         }
-        encoded_frame->is_key_frame_ = 1;
-        enc->prev_candidate_undecided_ = 1;
-        enc->keyframe_ = (int)position;
-        enc->best_delta_ = curr_delta;
-        enc->flush_count_ = enc->count_ - 1;  // We can flush previous frames.
+        encoded_frame->is_key_frame = 1;
+        enc->prev_candidate_undecided = 1;
+        enc->keyframe = (int)position;
+        enc->best_delta = curr_delta;
+        enc->flush_count = enc->count - 1;  // We can flush previous frames.
       } else {
-        encoded_frame->is_key_frame_ = 0;
-        enc->prev_candidate_undecided_ = 0;
+        encoded_frame->is_key_frame = 0;
+        enc->prev_candidate_undecided = 0;
       }
       // Note: We need '>=' below because when kmin and kmax are both zero,
       // count_since_key_frame will always be > kmax.
-      if (enc->count_since_key_frame_ >= enc->options_.kmax) {
-        enc->flush_count_ = enc->count_ - 1;
-        enc->count_since_key_frame_ = 0;
-        enc->keyframe_ = KEYFRAME_NONE;
-        enc->best_delta_ = DELTA_INFINITY;
+      if (enc->count_since_key_frame >= enc->options.kmax) {
+        enc->flush_count = enc->count - 1;
+        enc->count_since_key_frame = 0;
+        enc->keyframe = KEYFRAME_NONE;
+        enc->best_delta = DELTA_INFINITY;
       }
-      if (!enc->prev_candidate_undecided_) {
-        enc->prev_rect_ =
-            encoded_frame->is_key_frame_ ? prev_rect_key : prev_rect_sub;
+      if (!enc->prev_candidate_undecided) {
+        enc->prev_rect =
+            encoded_frame->is_key_frame ? prev_rect_key : prev_rect_sub;
       }
     }
   }
 
   // Update previous to previous and previous canvases for next call.
-  WebPCopyPixels(enc->curr_canvas_, &enc->prev_canvas_);
-  enc->is_first_frame_ = 0;
+  WebPCopyPixels(enc->curr_canvas, &enc->prev_canvas);
+  enc->is_first_frame = 0;
 
  Skip:
   ok = 1;
-  ++enc->in_frame_count_;
+  ++enc->in_frame_count;
 
  End:
   if (!ok || frame_skipped) {
     FrameRelease(encoded_frame);
     // We reset some counters, as the frame addition failed/was skipped.
-    --enc->count_;
-    if (!enc->is_first_frame_) --enc->count_since_key_frame_;
+    --enc->count;
+    if (!enc->is_first_frame) --enc->count_since_key_frame;
     if (!ok) {
       MarkError2(enc, "ERROR adding frame. WebPEncodingError", error_code);
     }
   }
-  enc->curr_canvas_->error_code = error_code;   // report error_code
+  enc->curr_canvas->error_code = error_code;   // report error_code
   assert(ok || error_code != VP8_ENC_OK);
   return ok;
 }
 
 static int FlushFrames(WebPAnimEncoder* const enc) {
-  while (enc->flush_count_ > 0) {
+  while (enc->flush_count > 0) {
     WebPMuxError err;
     EncodedFrame* const curr = GetFrame(enc, 0);
     const WebPMuxFrameInfo* const info =
-        curr->is_key_frame_ ? &curr->key_frame_ : &curr->sub_frame_;
-    assert(enc->mux_ != NULL);
-    err = WebPMuxPushFrame(enc->mux_, info, 1);
+        curr->is_key_frame ? &curr->key_frame : &curr->sub_frame;
+    assert(enc->mux != NULL);
+    err = WebPMuxPushFrame(enc->mux, info, 1);
     if (err != WEBP_MUX_OK) {
       MarkError2(enc, "ERROR adding frame. WebPMuxError", err);
       return 0;
     }
-    if (enc->options_.verbose) {
+    if (enc->options.verbose) {
       fprintf(stderr, "INFO: Added frame. offset:%d,%d dispose:%d blend:%d\n",
               info->x_offset, info->y_offset, info->dispose_method,
               info->blend_method);
     }
-    ++enc->out_frame_count_;
+    ++enc->out_frame_count;
     FrameRelease(curr);
-    ++enc->start_;
-    --enc->flush_count_;
-    --enc->count_;
-    if (enc->keyframe_ != KEYFRAME_NONE) --enc->keyframe_;
+    ++enc->start;
+    --enc->flush_count;
+    --enc->count;
+    if (enc->keyframe != KEYFRAME_NONE) --enc->keyframe;
   }
 
-  if (enc->count_ == 1 && enc->start_ != 0) {
+  if (enc->count == 1 && enc->start != 0) {
     // Move enc->start to index 0.
-    const int enc_start_tmp = (int)enc->start_;
-    EncodedFrame temp = enc->encoded_frames_[0];
-    enc->encoded_frames_[0] = enc->encoded_frames_[enc_start_tmp];
-    enc->encoded_frames_[enc_start_tmp] = temp;
-    FrameRelease(&enc->encoded_frames_[enc_start_tmp]);
-    enc->start_ = 0;
+    const int enc_start_tmp = (int)enc->start;
+    EncodedFrame temp = enc->encoded_frames[0];
+    enc->encoded_frames[0] = enc->encoded_frames[enc_start_tmp];
+    enc->encoded_frames[enc_start_tmp] = temp;
+    FrameRelease(&enc->encoded_frames[enc_start_tmp]);
+    enc->start = 0;
   }
   return 1;
 }
@@ -1345,10 +1347,10 @@ int WebPAnimEncoderAdd(WebPAnimEncoder* enc, WebPPicture* frame, int timestamp,
   }
   MarkNoError(enc);
 
-  if (!enc->is_first_frame_) {
+  if (!enc->is_first_frame) {
     // Make sure timestamps are non-decreasing (integer wrap-around is OK).
     const uint32_t prev_frame_duration =
-        (uint32_t)timestamp - enc->prev_timestamp_;
+        (uint32_t)timestamp - enc->prev_timestamp;
     if (prev_frame_duration >= MAX_DURATION) {
       if (frame != NULL) {
         frame->error_code = VP8_ENC_ERROR_INVALID_CONFIGURATION;
@@ -1360,30 +1362,30 @@ int WebPAnimEncoderAdd(WebPAnimEncoder* enc, WebPPicture* frame, int timestamp,
       return 0;
     }
     // IncreasePreviousDuration() may add a frame to avoid exceeding
-    // MAX_DURATION which could cause CacheFrame() to over read encoded_frames_
+    // MAX_DURATION which could cause CacheFrame() to over read 'encoded_frames'
     // before the next flush.
-    if (enc->count_ == enc->size_ && !FlushFrames(enc)) {
+    if (enc->count == enc->size && !FlushFrames(enc)) {
       return 0;
     }
   } else {
-    enc->first_timestamp_ = timestamp;
+    enc->first_timestamp = timestamp;
   }
 
   if (frame == NULL) {  // Special: last call.
-    enc->got_null_frame_ = 1;
-    enc->prev_timestamp_ = timestamp;
+    enc->got_null_frame = 1;
+    enc->prev_timestamp = timestamp;
     return 1;
   }
 
-  if (frame->width != enc->canvas_width_ ||
-      frame->height != enc->canvas_height_) {
+  if (frame->width != enc->canvas_width ||
+      frame->height != enc->canvas_height) {
     frame->error_code = VP8_ENC_ERROR_INVALID_CONFIGURATION;
     MarkError(enc, "ERROR adding frame: Invalid frame dimensions");
     return 0;
   }
 
   if (!frame->use_argb) {  // Convert frame from YUV(A) to ARGB.
-    if (enc->options_.verbose) {
+    if (enc->options.verbose) {
       fprintf(stderr, "WARNING: Converting frame from YUV(A) to ARGB format; "
               "this incurs a small loss.\n");
     }
@@ -1406,17 +1408,17 @@ int WebPAnimEncoderAdd(WebPAnimEncoder* enc, WebPPicture* frame, int timestamp,
     }
     config.lossless = 1;
   }
-  assert(enc->curr_canvas_ == NULL);
-  enc->curr_canvas_ = frame;  // Store reference.
-  assert(enc->curr_canvas_copy_modified_ == 1);
+  assert(enc->curr_canvas == NULL);
+  enc->curr_canvas = frame;  // Store reference.
+  assert(enc->curr_canvas_copy_modified == 1);
   CopyCurrentCanvas(enc);
 
   ok = CacheFrame(enc, &config) && FlushFrames(enc);
 
-  enc->curr_canvas_ = NULL;
-  enc->curr_canvas_copy_modified_ = 1;
+  enc->curr_canvas = NULL;
+  enc->curr_canvas_copy_modified = 1;
   if (ok) {
-    enc->prev_timestamp_ = timestamp;
+    enc->prev_timestamp = timestamp;
   }
   return ok;
 }
@@ -1456,17 +1458,17 @@ WEBP_NODISCARD static int DecodeFrameOntoCanvas(
 static int FrameToFullCanvas(WebPAnimEncoder* const enc,
                              const WebPMuxFrameInfo* const frame,
                              WebPData* const full_image) {
-  WebPPicture* const canvas_buf = &enc->curr_canvas_copy_;
+  WebPPicture* const canvas_buf = &enc->curr_canvas_copy;
   WebPMemoryWriter mem1, mem2;
   WebPMemoryWriterInit(&mem1);
   WebPMemoryWriterInit(&mem2);
 
   if (!DecodeFrameOntoCanvas(frame, canvas_buf)) goto Err;
-  if (!EncodeFrame(&enc->last_config_, canvas_buf, &mem1)) goto Err;
+  if (!EncodeFrame(&enc->last_config, canvas_buf, &mem1)) goto Err;
   GetEncodedData(&mem1, full_image);
 
-  if (enc->options_.allow_mixed) {
-    if (!EncodeFrame(&enc->last_config_reversed_, canvas_buf, &mem2)) goto Err;
+  if (enc->options.allow_mixed) {
+    if (!EncodeFrame(&enc->last_config_reversed, canvas_buf, &mem2)) goto Err;
     if (mem2.size < mem1.size) {
       GetEncodedData(&mem2, full_image);
       WebPMemoryWriterClear(&mem1);
@@ -1494,7 +1496,7 @@ static WebPMuxError OptimizeSingleFrame(WebPAnimEncoder* const enc,
   WebPData webp_data2;
   WebPMux* const mux = WebPMuxCreate(webp_data, 0);
   if (mux == NULL) return WEBP_MUX_BAD_DATA;
-  assert(enc->out_frame_count_ == 1);
+  assert(enc->out_frame_count == 1);
   WebPDataInit(&frame.bitstream);
   WebPDataInit(&full_image);
   WebPDataInit(&webp_data2);
@@ -1541,40 +1543,40 @@ int WebPAnimEncoderAssemble(WebPAnimEncoder* enc, WebPData* webp_data) {
     return 0;
   }
 
-  if (enc->in_frame_count_ == 0) {
+  if (enc->in_frame_count == 0) {
     MarkError(enc, "ERROR: No frames to assemble");
     return 0;
   }
 
-  if (!enc->got_null_frame_ && enc->in_frame_count_ > 1 && enc->count_ > 0) {
+  if (!enc->got_null_frame && enc->in_frame_count > 1 && enc->count > 0) {
     // set duration of the last frame to be avg of durations of previous frames.
     const double delta_time =
-        (uint32_t)enc->prev_timestamp_ - enc->first_timestamp_;
-    const int average_duration = (int)(delta_time / (enc->in_frame_count_ - 1));
+        (uint32_t)enc->prev_timestamp - enc->first_timestamp;
+    const int average_duration = (int)(delta_time / (enc->in_frame_count - 1));
     if (!IncreasePreviousDuration(enc, average_duration)) {
       return 0;
     }
   }
 
   // Flush any remaining frames.
-  enc->flush_count_ = enc->count_;
+  enc->flush_count = enc->count;
   if (!FlushFrames(enc)) {
     return 0;
   }
 
   // Set definitive canvas size.
-  mux = enc->mux_;
-  err = WebPMuxSetCanvasSize(mux, enc->canvas_width_, enc->canvas_height_);
+  mux = enc->mux;
+  err = WebPMuxSetCanvasSize(mux, enc->canvas_width, enc->canvas_height);
   if (err != WEBP_MUX_OK) goto Err;
 
-  err = WebPMuxSetAnimationParams(mux, &enc->options_.anim_params);
+  err = WebPMuxSetAnimationParams(mux, &enc->options.anim_params);
   if (err != WEBP_MUX_OK) goto Err;
 
   // Assemble into a WebP bitstream.
   err = WebPMuxAssemble(mux, webp_data);
   if (err != WEBP_MUX_OK) goto Err;
 
-  if (enc->out_frame_count_ == 1) {
+  if (enc->out_frame_count == 1) {
     err = OptimizeSingleFrame(enc, webp_data);
     if (err != WEBP_MUX_OK) goto Err;
   }
@@ -1587,26 +1589,26 @@ int WebPAnimEncoderAssemble(WebPAnimEncoder* enc, WebPData* webp_data) {
 
 const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc) {
   if (enc == NULL) return NULL;
-  return enc->error_str_;
+  return enc->error_str;
 }
 
 WebPMuxError WebPAnimEncoderSetChunk(
     WebPAnimEncoder* enc, const char fourcc[4], const WebPData* chunk_data,
     int copy_data) {
   if (enc == NULL) return WEBP_MUX_INVALID_ARGUMENT;
-  return WebPMuxSetChunk(enc->mux_, fourcc, chunk_data, copy_data);
+  return WebPMuxSetChunk(enc->mux, fourcc, chunk_data, copy_data);
 }
 
 WebPMuxError WebPAnimEncoderGetChunk(
     const WebPAnimEncoder* enc, const char fourcc[4], WebPData* chunk_data) {
   if (enc == NULL) return WEBP_MUX_INVALID_ARGUMENT;
-  return WebPMuxGetChunk(enc->mux_, fourcc, chunk_data);
+  return WebPMuxGetChunk(enc->mux, fourcc, chunk_data);
 }
 
 WebPMuxError WebPAnimEncoderDeleteChunk(
     WebPAnimEncoder* enc, const char fourcc[4]) {
   if (enc == NULL) return WEBP_MUX_INVALID_ARGUMENT;
-  return WebPMuxDeleteChunk(enc->mux_, fourcc);
+  return WebPMuxDeleteChunk(enc->mux, fourcc);
 }
 
 // -----------------------------------------------------------------------------