Intermediate changes

commit_hash:9e9c04347de10235f77fcdaf62119e9b89e8bc59

1 files changed, 168 insertions, 163 deletions

diff --git a/contrib/libs/libwebp/src/enc/frame_enc.c b/contrib/libs/libwebp/src/enc/frame_enc.c
index 01860ca757e..5a50085c72a 100644
--- a/contrib/libs/libwebp/src/enc/frame_enc.c
+++ b/contrib/libs/libwebp/src/enc/frame_enc.c
@@ -11,12 +11,17 @@
 //
 // Author: Skal ([email protected])
 
-#include <string.h>
+#include <assert.h>
 #include <math.h>
+#include <string.h>
 
+#include "src/dec/common_dec.h"
+#include "src/webp/types.h"
+#include "src/dsp/dsp.h"
 #include "src/enc/cost_enc.h"
 #include "src/enc/vp8i_enc.h"
-#include "src/dsp/dsp.h"
+#include "src/utils/bit_writer_utils.h"
+#include "src/webp/encode.h"
 #include "src/webp/format_constants.h"  // RIFF constants
 
 #define SEGMENT_VISU 0
@@ -46,15 +51,15 @@ typedef struct {  // struct for organizing convergence in either size or PSNR
 } PassStats;
 
 static int InitPassStats(const VP8Encoder* const enc, PassStats* const s) {
-  const uint64_t target_size = (uint64_t)enc->config_->target_size;
+  const uint64_t target_size = (uint64_t)enc->config->target_size;
   const int do_size_search = (target_size != 0);
-  const float target_PSNR = enc->config_->target_PSNR;
+  const float target_PSNR = enc->config->target_PSNR;
 
   s->is_first = 1;
   s->dq = 10.f;
-  s->qmin = 1.f * enc->config_->qmin;
-  s->qmax = 1.f * enc->config_->qmax;
-  s->q = s->last_q = Clamp(enc->config_->quality, s->qmin, s->qmax);
+  s->qmin = 1.f * enc->config->qmin;
+  s->qmax = 1.f * enc->config->qmax;
+  s->q = s->last_q = Clamp(enc->config->quality, s->qmin, s->qmax);
   s->target = do_size_search ? (double)target_size
             : (target_PSNR > 0.) ? target_PSNR
             : 40.;   // default, just in case
@@ -95,9 +100,9 @@ const uint8_t VP8Cat6[] =
 // Reset the statistics about: number of skips, token proba, level cost,...
 
 static void ResetStats(VP8Encoder* const enc) {
-  VP8EncProba* const proba = &enc->proba_;
+  VP8EncProba* const proba = &enc->proba;
   VP8CalculateLevelCosts(proba);
-  proba->nb_skip_ = 0;
+  proba->nb_skip = 0;
 }
 
 //------------------------------------------------------------------------------
@@ -111,17 +116,17 @@ static int CalcSkipProba(uint64_t nb, uint64_t total) {
 
 // Returns the bit-cost for coding the skip probability.
 static int FinalizeSkipProba(VP8Encoder* const enc) {
-  VP8EncProba* const proba = &enc->proba_;
-  const int nb_mbs = enc->mb_w_ * enc->mb_h_;
-  const int nb_events = proba->nb_skip_;
+  VP8EncProba* const proba = &enc->proba;
+  const int nb_mbs = enc->mb_w * enc->mb_h;
+  const int nb_events = proba->nb_skip;
   int size;
-  proba->skip_proba_ = CalcSkipProba(nb_events, nb_mbs);
-  proba->use_skip_proba_ = (proba->skip_proba_ < SKIP_PROBA_THRESHOLD);
+  proba->skip_proba = CalcSkipProba(nb_events, nb_mbs);
+  proba->use_skip_proba = (proba->skip_proba < SKIP_PROBA_THRESHOLD);
   size = 256;   // 'use_skip_proba' bit
-  if (proba->use_skip_proba_) {
-    size +=  nb_events * VP8BitCost(1, proba->skip_proba_)
-         + (nb_mbs - nb_events) * VP8BitCost(0, proba->skip_proba_);
-    size += 8 * 256;   // cost of signaling the skip_proba_ itself.
+  if (proba->use_skip_proba) {
+    size +=  nb_events * VP8BitCost(1, proba->skip_proba)
+         + (nb_mbs - nb_events) * VP8BitCost(0, proba->skip_proba);
+    size += 8 * 256;   // cost of signaling the 'skip_proba' itself.
   }
   return size;
 }
@@ -139,8 +144,8 @@ static int BranchCost(int nb, int total, int proba) {
 }
 
 static void ResetTokenStats(VP8Encoder* const enc) {
-  VP8EncProba* const proba = &enc->proba_;
-  memset(proba->stats_, 0, sizeof(proba->stats_));
+  VP8EncProba* const proba = &enc->proba;
+  memset(proba->stats, 0, sizeof(proba->stats));
 }
 
 static int FinalizeTokenProbas(VP8EncProba* const proba) {
@@ -151,7 +156,7 @@ static int FinalizeTokenProbas(VP8EncProba* const proba) {
     for (b = 0; b < NUM_BANDS; ++b) {
       for (c = 0; c < NUM_CTX; ++c) {
         for (p = 0; p < NUM_PROBAS; ++p) {
-          const proba_t stats = proba->stats_[t][b][c][p];
+          const proba_t stats = proba->stats[t][b][c][p];
           const int nb = (stats >> 0) & 0xffff;
           const int total = (stats >> 16) & 0xffff;
           const int update_proba = VP8CoeffsUpdateProba[t][b][c][p];
@@ -165,17 +170,17 @@ static int FinalizeTokenProbas(VP8EncProba* const proba) {
           const int use_new_p = (old_cost > new_cost);
           size += VP8BitCost(use_new_p, update_proba);
           if (use_new_p) {  // only use proba that seem meaningful enough.
-            proba->coeffs_[t][b][c][p] = new_p;
+            proba->coeffs[t][b][c][p] = new_p;
             has_changed |= (new_p != old_p);
             size += 8 * 256;
           } else {
-            proba->coeffs_[t][b][c][p] = old_p;
+            proba->coeffs[t][b][c][p] = old_p;
           }
         }
       }
     }
   }
-  proba->dirty_ = has_changed;
+  proba->dirty = has_changed;
   return size;
 }
 
@@ -190,8 +195,8 @@ static int GetProba(int a, int b) {
 
 static void ResetSegments(VP8Encoder* const enc) {
   int n;
-  for (n = 0; n < enc->mb_w_ * enc->mb_h_; ++n) {
-    enc->mb_info_[n].segment_ = 0;
+  for (n = 0; n < enc->mb_w * enc->mb_h; ++n) {
+    enc->mb_info[n].segment = 0;
   }
 }
 
@@ -199,34 +204,34 @@ static void SetSegmentProbas(VP8Encoder* const enc) {
   int p[NUM_MB_SEGMENTS] = { 0 };
   int n;
 
-  for (n = 0; n < enc->mb_w_ * enc->mb_h_; ++n) {
-    const VP8MBInfo* const mb = &enc->mb_info_[n];
-    ++p[mb->segment_];
+  for (n = 0; n < enc->mb_w * enc->mb_h; ++n) {
+    const VP8MBInfo* const mb = &enc->mb_info[n];
+    ++p[mb->segment];
   }
 #if !defined(WEBP_DISABLE_STATS)
-  if (enc->pic_->stats != NULL) {
+  if (enc->pic->stats != NULL) {
     for (n = 0; n < NUM_MB_SEGMENTS; ++n) {
-      enc->pic_->stats->segment_size[n] = p[n];
+      enc->pic->stats->segment_size[n] = p[n];
     }
   }
 #endif
-  if (enc->segment_hdr_.num_segments_ > 1) {
-    uint8_t* const probas = enc->proba_.segments_;
+  if (enc->segment_hdr.num_segments > 1) {
+    uint8_t* const probas = enc->proba.segments;
     probas[0] = GetProba(p[0] + p[1], p[2] + p[3]);
     probas[1] = GetProba(p[0], p[1]);
     probas[2] = GetProba(p[2], p[3]);
 
-    enc->segment_hdr_.update_map_ =
+    enc->segment_hdr.update_map =
         (probas[0] != 255) || (probas[1] != 255) || (probas[2] != 255);
-    if (!enc->segment_hdr_.update_map_) ResetSegments(enc);
-    enc->segment_hdr_.size_ =
+    if (!enc->segment_hdr.update_map) ResetSegments(enc);
+    enc->segment_hdr.size =
         p[0] * (VP8BitCost(0, probas[0]) + VP8BitCost(0, probas[1])) +
         p[1] * (VP8BitCost(0, probas[0]) + VP8BitCost(1, probas[1])) +
         p[2] * (VP8BitCost(1, probas[0]) + VP8BitCost(0, probas[2])) +
         p[3] * (VP8BitCost(1, probas[0]) + VP8BitCost(1, probas[2]));
   } else {
-    enc->segment_hdr_.update_map_ = 0;
-    enc->segment_hdr_.size_ = 0;
+    enc->segment_hdr.update_map = 0;
+    enc->segment_hdr.size = 0;
   }
 }
 
@@ -311,9 +316,9 @@ static void CodeResiduals(VP8BitWriter* const bw, VP8EncIterator* const it,
   int x, y, ch;
   VP8Residual res;
   uint64_t pos1, pos2, pos3;
-  const int i16 = (it->mb_->type_ == 1);
-  const int segment = it->mb_->segment_;
-  VP8Encoder* const enc = it->enc_;
+  const int i16 = (it->mb->type == 1);
+  const int segment = it->mb->segment;
+  VP8Encoder* const enc = it->enc;
 
   VP8IteratorNzToBytes(it);
 
@@ -321,8 +326,8 @@ static void CodeResiduals(VP8BitWriter* const bw, VP8EncIterator* const it,
   if (i16) {
     VP8InitResidual(0, 1, enc, &res);
     VP8SetResidualCoeffs(rd->y_dc_levels, &res);
-    it->top_nz_[8] = it->left_nz_[8] =
-      PutCoeffs(bw, it->top_nz_[8] + it->left_nz_[8], &res);
+    it->top_nz[8] = it->left_nz[8] =
+        PutCoeffs(bw, it->top_nz[8] + it->left_nz[8], &res);
     VP8InitResidual(1, 0, enc, &res);
   } else {
     VP8InitResidual(0, 3, enc, &res);
@@ -331,9 +336,9 @@ static void CodeResiduals(VP8BitWriter* const bw, VP8EncIterator* const it,
   // luma-AC
   for (y = 0; y < 4; ++y) {
     for (x = 0; x < 4; ++x) {
-      const int ctx = it->top_nz_[x] + it->left_nz_[y];
+      const int ctx = it->top_nz[x] + it->left_nz[y];
       VP8SetResidualCoeffs(rd->y_ac_levels[x + y * 4], &res);
-      it->top_nz_[x] = it->left_nz_[y] = PutCoeffs(bw, ctx, &res);
+      it->top_nz[x] = it->left_nz[y] = PutCoeffs(bw, ctx, &res);
     }
   }
   pos2 = VP8BitWriterPos(bw);
@@ -343,18 +348,18 @@ static void CodeResiduals(VP8BitWriter* const bw, VP8EncIterator* const it,
   for (ch = 0; ch <= 2; ch += 2) {
     for (y = 0; y < 2; ++y) {
       for (x = 0; x < 2; ++x) {
-        const int ctx = it->top_nz_[4 + ch + x] + it->left_nz_[4 + ch + y];
+        const int ctx = it->top_nz[4 + ch + x] + it->left_nz[4 + ch + y];
         VP8SetResidualCoeffs(rd->uv_levels[ch * 2 + x + y * 2], &res);
-        it->top_nz_[4 + ch + x] = it->left_nz_[4 + ch + y] =
+        it->top_nz[4 + ch + x] = it->left_nz[4 + ch + y] =
             PutCoeffs(bw, ctx, &res);
       }
     }
   }
   pos3 = VP8BitWriterPos(bw);
-  it->luma_bits_ = pos2 - pos1;
-  it->uv_bits_ = pos3 - pos2;
-  it->bit_count_[segment][i16] += it->luma_bits_;
-  it->bit_count_[segment][2] += it->uv_bits_;
+  it->luma_bits = pos2 - pos1;
+  it->uv_bits = pos3 - pos2;
+  it->bit_count[segment][i16] += it->luma_bits;
+  it->bit_count[segment][2] += it->uv_bits;
   VP8IteratorBytesToNz(it);
 }
 
@@ -364,15 +369,15 @@ static void RecordResiduals(VP8EncIterator* const it,
                             const VP8ModeScore* const rd) {
   int x, y, ch;
   VP8Residual res;
-  VP8Encoder* const enc = it->enc_;
+  VP8Encoder* const enc = it->enc;
 
   VP8IteratorNzToBytes(it);
 
-  if (it->mb_->type_ == 1) {   // i16x16
+  if (it->mb->type == 1) {   // i16x16
     VP8InitResidual(0, 1, enc, &res);
     VP8SetResidualCoeffs(rd->y_dc_levels, &res);
-    it->top_nz_[8] = it->left_nz_[8] =
-      VP8RecordCoeffs(it->top_nz_[8] + it->left_nz_[8], &res);
+    it->top_nz[8] = it->left_nz[8] =
+        VP8RecordCoeffs(it->top_nz[8] + it->left_nz[8], &res);
     VP8InitResidual(1, 0, enc, &res);
   } else {
     VP8InitResidual(0, 3, enc, &res);
@@ -381,9 +386,9 @@ static void RecordResiduals(VP8EncIterator* const it,
   // luma-AC
   for (y = 0; y < 4; ++y) {
     for (x = 0; x < 4; ++x) {
-      const int ctx = it->top_nz_[x] + it->left_nz_[y];
+      const int ctx = it->top_nz[x] + it->left_nz[y];
       VP8SetResidualCoeffs(rd->y_ac_levels[x + y * 4], &res);
-      it->top_nz_[x] = it->left_nz_[y] = VP8RecordCoeffs(ctx, &res);
+      it->top_nz[x] = it->left_nz[y] = VP8RecordCoeffs(ctx, &res);
     }
   }
 
@@ -392,9 +397,9 @@ static void RecordResiduals(VP8EncIterator* const it,
   for (ch = 0; ch <= 2; ch += 2) {
     for (y = 0; y < 2; ++y) {
       for (x = 0; x < 2; ++x) {
-        const int ctx = it->top_nz_[4 + ch + x] + it->left_nz_[4 + ch + y];
+        const int ctx = it->top_nz[4 + ch + x] + it->left_nz[4 + ch + y];
         VP8SetResidualCoeffs(rd->uv_levels[ch * 2 + x + y * 2], &res);
-        it->top_nz_[4 + ch + x] = it->left_nz_[4 + ch + y] =
+        it->top_nz[4 + ch + x] = it->left_nz[4 + ch + y] =
             VP8RecordCoeffs(ctx, &res);
       }
     }
@@ -412,14 +417,14 @@ static int RecordTokens(VP8EncIterator* const it, const VP8ModeScore* const rd,
                         VP8TBuffer* const tokens) {
   int x, y, ch;
   VP8Residual res;
-  VP8Encoder* const enc = it->enc_;
+  VP8Encoder* const enc = it->enc;
 
   VP8IteratorNzToBytes(it);
-  if (it->mb_->type_ == 1) {   // i16x16
-    const int ctx = it->top_nz_[8] + it->left_nz_[8];
+  if (it->mb->type == 1) {   // i16x16
+    const int ctx = it->top_nz[8] + it->left_nz[8];
     VP8InitResidual(0, 1, enc, &res);
     VP8SetResidualCoeffs(rd->y_dc_levels, &res);
-    it->top_nz_[8] = it->left_nz_[8] =
+    it->top_nz[8] = it->left_nz[8] =
         VP8RecordCoeffTokens(ctx, &res, tokens);
     VP8InitResidual(1, 0, enc, &res);
   } else {
@@ -429,9 +434,9 @@ static int RecordTokens(VP8EncIterator* const it, const VP8ModeScore* const rd,
   // luma-AC
   for (y = 0; y < 4; ++y) {
     for (x = 0; x < 4; ++x) {
-      const int ctx = it->top_nz_[x] + it->left_nz_[y];
+      const int ctx = it->top_nz[x] + it->left_nz[y];
       VP8SetResidualCoeffs(rd->y_ac_levels[x + y * 4], &res);
-      it->top_nz_[x] = it->left_nz_[y] =
+      it->top_nz[x] = it->left_nz[y] =
           VP8RecordCoeffTokens(ctx, &res, tokens);
     }
   }
@@ -441,15 +446,15 @@ static int RecordTokens(VP8EncIterator* const it, const VP8ModeScore* const rd,
   for (ch = 0; ch <= 2; ch += 2) {
     for (y = 0; y < 2; ++y) {
       for (x = 0; x < 2; ++x) {
-        const int ctx = it->top_nz_[4 + ch + x] + it->left_nz_[4 + ch + y];
+        const int ctx = it->top_nz[4 + ch + x] + it->left_nz[4 + ch + y];
         VP8SetResidualCoeffs(rd->uv_levels[ch * 2 + x + y * 2], &res);
-        it->top_nz_[4 + ch + x] = it->left_nz_[4 + ch + y] =
+        it->top_nz[4 + ch + x] = it->left_nz[4 + ch + y] =
             VP8RecordCoeffTokens(ctx, &res, tokens);
       }
     }
   }
   VP8IteratorBytesToNz(it);
-  return !tokens->error_;
+  return !tokens->error;
 }
 
 #endif    // !DISABLE_TOKEN_BUFFER
@@ -470,64 +475,64 @@ static void SetBlock(uint8_t* p, int value, int size) {
 #endif
 
 static void ResetSSE(VP8Encoder* const enc) {
-  enc->sse_[0] = 0;
-  enc->sse_[1] = 0;
-  enc->sse_[2] = 0;
-  // Note: enc->sse_[3] is managed by alpha.c
-  enc->sse_count_ = 0;
+  enc->sse[0] = 0;
+  enc->sse[1] = 0;
+  enc->sse[2] = 0;
+  // Note: enc->sse[3] is managed by alpha.c
+  enc->sse_count = 0;
 }
 
 static void StoreSSE(const VP8EncIterator* const it) {
-  VP8Encoder* const enc = it->enc_;
-  const uint8_t* const in = it->yuv_in_;
-  const uint8_t* const out = it->yuv_out_;
+  VP8Encoder* const enc = it->enc;
+  const uint8_t* const in = it->yuv_in;
+  const uint8_t* const out = it->yuv_out;
   // Note: not totally accurate at boundary. And doesn't include in-loop filter.
-  enc->sse_[0] += VP8SSE16x16(in + Y_OFF_ENC, out + Y_OFF_ENC);
-  enc->sse_[1] += VP8SSE8x8(in + U_OFF_ENC, out + U_OFF_ENC);
-  enc->sse_[2] += VP8SSE8x8(in + V_OFF_ENC, out + V_OFF_ENC);
-  enc->sse_count_ += 16 * 16;
+  enc->sse[0] += VP8SSE16x16(in + Y_OFF_ENC, out + Y_OFF_ENC);
+  enc->sse[1] += VP8SSE8x8(in + U_OFF_ENC, out + U_OFF_ENC);
+  enc->sse[2] += VP8SSE8x8(in + V_OFF_ENC, out + V_OFF_ENC);
+  enc->sse_count += 16 * 16;
 }
 
 static void StoreSideInfo(const VP8EncIterator* const it) {
-  VP8Encoder* const enc = it->enc_;
-  const VP8MBInfo* const mb = it->mb_;
-  WebPPicture* const pic = enc->pic_;
+  VP8Encoder* const enc = it->enc;
+  const VP8MBInfo* const mb = it->mb;
+  WebPPicture* const pic = enc->pic;
 
   if (pic->stats != NULL) {
     StoreSSE(it);
-    enc->block_count_[0] += (mb->type_ == 0);
-    enc->block_count_[1] += (mb->type_ == 1);
-    enc->block_count_[2] += (mb->skip_ != 0);
+    enc->block_count[0] += (mb->type == 0);
+    enc->block_count[1] += (mb->type == 1);
+    enc->block_count[2] += (mb->skip != 0);
   }
 
   if (pic->extra_info != NULL) {
-    uint8_t* const info = &pic->extra_info[it->x_ + it->y_ * enc->mb_w_];
+    uint8_t* const info = &pic->extra_info[it->x + it->y * enc->mb_w];
     switch (pic->extra_info_type) {
-      case 1: *info = mb->type_; break;
-      case 2: *info = mb->segment_; break;
-      case 3: *info = enc->dqm_[mb->segment_].quant_; break;
-      case 4: *info = (mb->type_ == 1) ? it->preds_[0] : 0xff; break;
-      case 5: *info = mb->uv_mode_; break;
+      case 1: *info = mb->type; break;
+      case 2: *info = mb->segment; break;
+      case 3: *info = enc->dqm[mb->segment].quant; break;
+      case 4: *info = (mb->type == 1) ? it->preds[0] : 0xff; break;
+      case 5: *info = mb->uv_mode; break;
       case 6: {
-        const int b = (int)((it->luma_bits_ + it->uv_bits_ + 7) >> 3);
+        const int b = (int)((it->luma_bits + it->uv_bits + 7) >> 3);
         *info = (b > 255) ? 255 : b; break;
       }
-      case 7: *info = mb->alpha_; break;
+      case 7: *info = mb->alpha; break;
       default: *info = 0; break;
     }
   }
 #if SEGMENT_VISU  // visualize segments and prediction modes
-  SetBlock(it->yuv_out_ + Y_OFF_ENC, mb->segment_ * 64, 16);
-  SetBlock(it->yuv_out_ + U_OFF_ENC, it->preds_[0] * 64, 8);
-  SetBlock(it->yuv_out_ + V_OFF_ENC, mb->uv_mode_ * 64, 8);
+  SetBlock(it->yuv_out + Y_OFF_ENC, mb->segment * 64, 16);
+  SetBlock(it->yuv_out + U_OFF_ENC, it->preds[0] * 64, 8);
+  SetBlock(it->yuv_out + V_OFF_ENC, mb->uv_mode * 64, 8);
 #endif
 }
 
 static void ResetSideInfo(const VP8EncIterator* const it) {
-  VP8Encoder* const enc = it->enc_;
-  WebPPicture* const pic = enc->pic_;
+  VP8Encoder* const enc = it->enc;
+  WebPPicture* const pic = enc->pic;
   if (pic->stats != NULL) {
-    memset(enc->block_count_, 0, sizeof(enc->block_count_));
+    memset(enc->block_count, 0, sizeof(enc->block_count));
   }
   ResetSSE(enc);
 }
@@ -536,12 +541,12 @@ static void ResetSSE(VP8Encoder* const enc) {
   (void)enc;
 }
 static void StoreSideInfo(const VP8EncIterator* const it) {
-  VP8Encoder* const enc = it->enc_;
-  WebPPicture* const pic = enc->pic_;
+  VP8Encoder* const enc = it->enc;
+  WebPPicture* const pic = enc->pic;
   if (pic->extra_info != NULL) {
-    if (it->x_ == 0 && it->y_ == 0) {   // only do it once, at start
+    if (it->x == 0 && it->y == 0) {   // only do it once, at start
       memset(pic->extra_info, 0,
-             enc->mb_w_ * enc->mb_h_ * sizeof(*pic->extra_info));
+             enc->mb_w * enc->mb_h * sizeof(*pic->extra_info));
     }
   }
 }
@@ -587,7 +592,7 @@ static uint64_t OneStatPass(VP8Encoder* const enc, VP8RDLevel rd_opt,
     VP8IteratorImport(&it, NULL);
     if (VP8Decimate(&it, &info, rd_opt)) {
       // Just record the number of skips and act like skip_proba is not used.
-      ++enc->proba_.nb_skip_;
+      ++enc->proba.nb_skip;
     }
     RecordResiduals(&it, &info);
     size += info.R + info.H;
@@ -599,10 +604,10 @@ static uint64_t OneStatPass(VP8Encoder* const enc, VP8RDLevel rd_opt,
     VP8IteratorSaveBoundary(&it);
   } while (VP8IteratorNext(&it) && --nb_mbs > 0);
 
-  size_p0 += enc->segment_hdr_.size_;
+  size_p0 += enc->segment_hdr.size;
   if (s->do_size_search) {
     size += FinalizeSkipProba(enc);
-    size += FinalizeTokenProbas(&enc->proba_);
+    size += FinalizeTokenProbas(&enc->proba);
     size = ((size + size_p0 + 1024) >> 11) + HEADER_SIZE_ESTIMATE;
     s->value = (double)size;
   } else {
@@ -612,17 +617,17 @@ static uint64_t OneStatPass(VP8Encoder* const enc, VP8RDLevel rd_opt,
 }
 
 static int StatLoop(VP8Encoder* const enc) {
-  const int method = enc->method_;
-  const int do_search = enc->do_search_;
+  const int method = enc->method;
+  const int do_search = enc->do_search;
   const int fast_probe = ((method == 0 || method == 3) && !do_search);
-  int num_pass_left = enc->config_->pass;
+  int num_pass_left = enc->config->pass;
   const int task_percent = 20;
   const int percent_per_pass =
       (task_percent + num_pass_left / 2) / num_pass_left;
-  const int final_percent = enc->percent_ + task_percent;
+  const int final_percent = enc->percent + task_percent;
   const VP8RDLevel rd_opt =
       (method >= 3 || do_search) ? RD_OPT_BASIC : RD_OPT_NONE;
-  int nb_mbs = enc->mb_w_ * enc->mb_h_;
+  int nb_mbs = enc->mb_w * enc->mb_h;
   PassStats stats;
 
   InitPassStats(enc, &stats);
@@ -640,7 +645,7 @@ static int StatLoop(VP8Encoder* const enc) {
   while (num_pass_left-- > 0) {
     const int is_last_pass = (fabs(stats.dq) <= DQ_LIMIT) ||
                              (num_pass_left == 0) ||
-                             (enc->max_i4_header_bits_ == 0);
+                             (enc->max_i4_header_bits == 0);
     const uint64_t size_p0 =
         OneStatPass(enc, rd_opt, nb_mbs, percent_per_pass, &stats);
     if (size_p0 == 0) return 0;
@@ -648,9 +653,9 @@ static int StatLoop(VP8Encoder* const enc) {
     printf("#%d value:%.1lf -> %.1lf   q:%.2f -> %.2f\n",
            num_pass_left, stats.last_value, stats.value, stats.last_q, stats.q);
 #endif
-    if (enc->max_i4_header_bits_ > 0 && size_p0 > PARTITION0_SIZE_LIMIT) {
+    if (enc->max_i4_header_bits > 0 && size_p0 > PARTITION0_SIZE_LIMIT) {
       ++num_pass_left;
-      enc->max_i4_header_bits_ >>= 1;  // strengthen header bit limitation...
+      enc->max_i4_header_bits >>= 1;   // strengthen header bit limitation...
       continue;                        // ...and start over
     }
     if (is_last_pass) {
@@ -665,10 +670,10 @@ static int StatLoop(VP8Encoder* const enc) {
   if (!do_search || !stats.do_size_search) {
     // Need to finalize probas now, since it wasn't done during the search.
     FinalizeSkipProba(enc);
-    FinalizeTokenProbas(&enc->proba_);
+    FinalizeTokenProbas(&enc->proba);
   }
-  VP8CalculateLevelCosts(&enc->proba_);  // finalize costs
-  return WebPReportProgress(enc->pic_, final_percent, &enc->percent_);
+  VP8CalculateLevelCosts(&enc->proba);  // finalize costs
+  return WebPReportProgress(enc->pic, final_percent, &enc->percent);
 }
 
 //------------------------------------------------------------------------------
@@ -680,37 +685,37 @@ static const uint8_t kAverageBytesPerMB[8] = { 50, 24, 16, 9, 7, 5, 3, 2 };
 static int PreLoopInitialize(VP8Encoder* const enc) {
   int p;
   int ok = 1;
-  const int average_bytes_per_MB = kAverageBytesPerMB[enc->base_quant_ >> 4];
+  const int average_bytes_per_MB = kAverageBytesPerMB[enc->base_quant >> 4];
   const int bytes_per_parts =
-      enc->mb_w_ * enc->mb_h_ * average_bytes_per_MB / enc->num_parts_;
+      enc->mb_w * enc->mb_h * average_bytes_per_MB / enc->num_parts;
   // Initialize the bit-writers
-  for (p = 0; ok && p < enc->num_parts_; ++p) {
-    ok = VP8BitWriterInit(enc->parts_ + p, bytes_per_parts);
+  for (p = 0; ok && p < enc->num_parts; ++p) {
+    ok = VP8BitWriterInit(enc->parts + p, bytes_per_parts);
   }
   if (!ok) {
     VP8EncFreeBitWriters(enc);  // malloc error occurred
-    return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
+    return WebPEncodingSetError(enc->pic, VP8_ENC_ERROR_OUT_OF_MEMORY);
   }
   return ok;
 }
 
 static int PostLoopFinalize(VP8EncIterator* const it, int ok) {
-  VP8Encoder* const enc = it->enc_;
+  VP8Encoder* const enc = it->enc;
   if (ok) {      // Finalize the partitions, check for extra errors.
     int p;
-    for (p = 0; p < enc->num_parts_; ++p) {
-      VP8BitWriterFinish(enc->parts_ + p);
-      ok &= !enc->parts_[p].error_;
+    for (p = 0; p < enc->num_parts; ++p) {
+      VP8BitWriterFinish(enc->parts + p);
+      ok &= !enc->parts[p].error;
     }
   }
 
   if (ok) {      // All good. Finish up.
 #if !defined(WEBP_DISABLE_STATS)
-    if (enc->pic_->stats != NULL) {  // finalize byte counters...
+    if (enc->pic->stats != NULL) {  // finalize byte counters...
       int i, s;
       for (i = 0; i <= 2; ++i) {
         for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-          enc->residual_bytes_[i][s] = (int)((it->bit_count_[s][i] + 7) >> 3);
+          enc->residual_bytes[i][s] = (int)((it->bit_count[s][i] + 7) >> 3);
         }
       }
     }
@@ -719,7 +724,7 @@ static int PostLoopFinalize(VP8EncIterator* const it, int ok) {
   } else {
     // Something bad happened -> need to do some memory cleanup.
     VP8EncFreeBitWriters(enc);
-    return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
+    return WebPEncodingSetError(enc->pic, VP8_ENC_ERROR_OUT_OF_MEMORY);
   }
   return ok;
 }
@@ -728,11 +733,11 @@ static int PostLoopFinalize(VP8EncIterator* const it, int ok) {
 //  VP8EncLoop(): does the final bitstream coding.
 
 static void ResetAfterSkip(VP8EncIterator* const it) {
-  if (it->mb_->type_ == 1) {
-    *it->nz_ = 0;  // reset all predictors
-    it->left_nz_[8] = 0;
+  if (it->mb->type == 1) {
+    *it->nz = 0;  // reset all predictors
+    it->left_nz[8] = 0;
   } else {
-    *it->nz_ &= (1 << 24);  // preserve the dc_nz bit
+    *it->nz &= (1 << 24);  // preserve the dc_nz bit
   }
 }
 
@@ -747,16 +752,16 @@ int VP8EncLoop(VP8Encoder* const enc) {
   VP8InitFilter(&it);
   do {
     VP8ModeScore info;
-    const int dont_use_skip = !enc->proba_.use_skip_proba_;
-    const VP8RDLevel rd_opt = enc->rd_opt_level_;
+    const int dont_use_skip = !enc->proba.use_skip_proba;
+    const VP8RDLevel rd_opt = enc->rd_opt_level;
 
     VP8IteratorImport(&it, NULL);
     // Warning! order is important: first call VP8Decimate() and
     // *then* decide how to code the skip decision if there's one.
     if (!VP8Decimate(&it, &info, rd_opt) || dont_use_skip) {
-      CodeResiduals(it.bw_, &it, &info);
-      if (it.bw_->error_) {
-        // enc->pic_->error_code is set in PostLoopFinalize().
+      CodeResiduals(it.bw, &it, &info);
+      if (it.bw->error) {
+        // enc->pic->error_code is set in PostLoopFinalize().
         ok = 0;
         break;
       }
@@ -782,14 +787,14 @@ int VP8EncLoop(VP8Encoder* const enc) {
 
 int VP8EncTokenLoop(VP8Encoder* const enc) {
   // Roughly refresh the proba eight times per pass
-  int max_count = (enc->mb_w_ * enc->mb_h_) >> 3;
-  int num_pass_left = enc->config_->pass;
+  int max_count = (enc->mb_w * enc->mb_h) >> 3;
+  int num_pass_left = enc->config->pass;
   int remaining_progress = 40;  // percents
-  const int do_search = enc->do_search_;
+  const int do_search = enc->do_search;
   VP8EncIterator it;
-  VP8EncProba* const proba = &enc->proba_;
-  const VP8RDLevel rd_opt = enc->rd_opt_level_;
-  const uint64_t pixel_count = (uint64_t)enc->mb_w_ * enc->mb_h_ * 384;
+  VP8EncProba* const proba = &enc->proba;
+  const VP8RDLevel rd_opt = enc->rd_opt_level;
+  const uint64_t pixel_count = (uint64_t)enc->mb_w * enc->mb_h * 384;
   PassStats stats;
   int ok;
 
@@ -799,16 +804,16 @@ int VP8EncTokenLoop(VP8Encoder* const enc) {
 
   if (max_count < MIN_COUNT) max_count = MIN_COUNT;
 
-  assert(enc->num_parts_ == 1);
-  assert(enc->use_tokens_);
-  assert(proba->use_skip_proba_ == 0);
+  assert(enc->num_parts == 1);
+  assert(enc->use_tokens);
+  assert(proba->use_skip_proba == 0);
   assert(rd_opt >= RD_OPT_BASIC);   // otherwise, token-buffer won't be useful
   assert(num_pass_left > 0);
 
   while (ok && num_pass_left-- > 0) {
     const int is_last_pass = (fabs(stats.dq) <= DQ_LIMIT) ||
                              (num_pass_left == 0) ||
-                             (enc->max_i4_header_bits_ == 0);
+                             (enc->max_i4_header_bits == 0);
     uint64_t size_p0 = 0;
     uint64_t distortion = 0;
     int cnt = max_count;
@@ -821,7 +826,7 @@ int VP8EncTokenLoop(VP8Encoder* const enc) {
       ResetTokenStats(enc);
       VP8InitFilter(&it);  // don't collect stats until last pass (too costly)
     }
-    VP8TBufferClear(&enc->tokens_);
+    VP8TBufferClear(&enc->tokens);
     do {
       VP8ModeScore info;
       VP8IteratorImport(&it, NULL);
@@ -831,9 +836,9 @@ int VP8EncTokenLoop(VP8Encoder* const enc) {
         cnt = max_count;
       }
       VP8Decimate(&it, &info, rd_opt);
-      ok = RecordTokens(&it, &info, &enc->tokens_);
+      ok = RecordTokens(&it, &info, &enc->tokens);
       if (!ok) {
-        WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
+        WebPEncodingSetError(enc->pic, VP8_ENC_ERROR_OUT_OF_MEMORY);
         break;
       }
       size_p0 += info.H;
@@ -848,11 +853,11 @@ int VP8EncTokenLoop(VP8Encoder* const enc) {
     } while (ok && VP8IteratorNext(&it));
     if (!ok) break;
 
-    size_p0 += enc->segment_hdr_.size_;
+    size_p0 += enc->segment_hdr.size;
     if (stats.do_size_search) {
-      uint64_t size = FinalizeTokenProbas(&enc->proba_);
-      size += VP8EstimateTokenSize(&enc->tokens_,
-                                   (const uint8_t*)proba->coeffs_);
+      uint64_t size = FinalizeTokenProbas(&enc->proba);
+      size += VP8EstimateTokenSize(&enc->tokens,
+                                   (const uint8_t*)proba->coeffs);
       size = (size + size_p0 + 1024) >> 11;  // -> size in bytes
       size += HEADER_SIZE_ESTIMATE;
       stats.value = (double)size;
@@ -866,9 +871,9 @@ int VP8EncTokenLoop(VP8Encoder* const enc) {
            num_pass_left, stats.last_value, stats.value,
            stats.last_q, stats.q, stats.dq, stats.qmin, stats.qmax);
 #endif
-    if (enc->max_i4_header_bits_ > 0 && size_p0 > PARTITION0_SIZE_LIMIT) {
+    if (enc->max_i4_header_bits > 0 && size_p0 > PARTITION0_SIZE_LIMIT) {
       ++num_pass_left;
-      enc->max_i4_header_bits_ >>= 1;  // strengthen header bit limitation...
+      enc->max_i4_header_bits >>= 1;  // strengthen header bit limitation...
       if (is_last_pass) {
         ResetSideInfo(&it);
       }
@@ -883,13 +888,13 @@ int VP8EncTokenLoop(VP8Encoder* const enc) {
   }
   if (ok) {
     if (!stats.do_size_search) {
-      FinalizeTokenProbas(&enc->proba_);
+      FinalizeTokenProbas(&enc->proba);
     }
-    ok = VP8EmitTokens(&enc->tokens_, enc->parts_ + 0,
-                       (const uint8_t*)proba->coeffs_, 1);
+    ok = VP8EmitTokens(&enc->tokens, enc->parts + 0,
+                       (const uint8_t*)proba->coeffs, 1);
   }
-  ok = ok && WebPReportProgress(enc->pic_, enc->percent_ + remaining_progress,
-                                &enc->percent_);
+  ok = ok && WebPReportProgress(enc->pic, enc->percent + remaining_progress,
+                                &enc->percent);
   return PostLoopFinalize(&it, ok);
 }