Intermediate changes

commit_hash:9e9c04347de10235f77fcdaf62119e9b89e8bc59

1 files changed, 78 insertions, 74 deletions

diff --git a/contrib/libs/libwebp/src/enc/syntax_enc.c b/contrib/libs/libwebp/src/enc/syntax_enc.c
index 9b8f524d698..6edc3c21f33 100644
--- a/contrib/libs/libwebp/src/enc/syntax_enc.c
+++ b/contrib/libs/libwebp/src/enc/syntax_enc.c
@@ -12,18 +12,23 @@
 // Author: Skal ([email protected])
 
 #include <assert.h>
+#include <stddef.h>
 
+#include "src/dec/common_dec.h"
+#include "src/webp/types.h"
+#include "src/enc/vp8i_enc.h"
+#include "src/utils/bit_writer_utils.h"
 #include "src/utils/utils.h"
+#include "src/webp/encode.h"
 #include "src/webp/format_constants.h"  // RIFF constants
 #include "src/webp/mux_types.h"         // ALPHA_FLAG
-#include "src/enc/vp8i_enc.h"
 
 //------------------------------------------------------------------------------
 // Helper functions
 
 static int IsVP8XNeeded(const VP8Encoder* const enc) {
-  return !!enc->has_alpha_;  // Currently the only case when VP8X is needed.
-                             // This could change in the future.
+  return !!enc->has_alpha;  // Currently the only case when VP8X is needed.
+                            // This could change in the future.
 }
 
 static int PutPaddingByte(const WebPPicture* const pic) {
@@ -36,7 +41,7 @@ static int PutPaddingByte(const WebPPicture* const pic) {
 
 static WebPEncodingError PutRIFFHeader(const VP8Encoder* const enc,
                                        size_t riff_size) {
-  const WebPPicture* const pic = enc->pic_;
+  const WebPPicture* const pic = enc->pic;
   uint8_t riff[RIFF_HEADER_SIZE] = {
     'R', 'I', 'F', 'F', 0, 0, 0, 0, 'W', 'E', 'B', 'P'
   };
@@ -49,7 +54,7 @@ static WebPEncodingError PutRIFFHeader(const VP8Encoder* const enc,
 }
 
 static WebPEncodingError PutVP8XHeader(const VP8Encoder* const enc) {
-  const WebPPicture* const pic = enc->pic_;
+  const WebPPicture* const pic = enc->pic;
   uint8_t vp8x[CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE] = {
     'V', 'P', '8', 'X'
   };
@@ -59,7 +64,7 @@ static WebPEncodingError PutVP8XHeader(const VP8Encoder* const enc) {
   assert(pic->width >= 1 && pic->height >= 1);
   assert(pic->width <= MAX_CANVAS_SIZE && pic->height <= MAX_CANVAS_SIZE);
 
-  if (enc->has_alpha_) {
+  if (enc->has_alpha) {
     flags |= ALPHA_FLAG;
   }
 
@@ -74,26 +79,26 @@ static WebPEncodingError PutVP8XHeader(const VP8Encoder* const enc) {
 }
 
 static WebPEncodingError PutAlphaChunk(const VP8Encoder* const enc) {
-  const WebPPicture* const pic = enc->pic_;
+  const WebPPicture* const pic = enc->pic;
   uint8_t alpha_chunk_hdr[CHUNK_HEADER_SIZE] = {
     'A', 'L', 'P', 'H'
   };
 
-  assert(enc->has_alpha_);
+  assert(enc->has_alpha);
 
   // Alpha chunk header.
-  PutLE32(alpha_chunk_hdr + TAG_SIZE, enc->alpha_data_size_);
+  PutLE32(alpha_chunk_hdr + TAG_SIZE, enc->alpha_data_size);
   if (!pic->writer(alpha_chunk_hdr, sizeof(alpha_chunk_hdr), pic)) {
     return VP8_ENC_ERROR_BAD_WRITE;
   }
 
   // Alpha chunk data.
-  if (!pic->writer(enc->alpha_data_, enc->alpha_data_size_, pic)) {
+  if (!pic->writer(enc->alpha_data, enc->alpha_data_size, pic)) {
     return VP8_ENC_ERROR_BAD_WRITE;
   }
 
   // Padding.
-  if ((enc->alpha_data_size_ & 1) && !PutPaddingByte(pic)) {
+  if ((enc->alpha_data_size & 1) && !PutPaddingByte(pic)) {
     return VP8_ENC_ERROR_BAD_WRITE;
   }
   return VP8_ENC_OK;
@@ -148,7 +153,7 @@ static WebPEncodingError PutVP8FrameHeader(const WebPPicture* const pic,
 // WebP Headers.
 static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
                           size_t vp8_size, size_t riff_size) {
-  WebPPicture* const pic = enc->pic_;
+  WebPPicture* const pic = enc->pic;
   WebPEncodingError err = VP8_ENC_OK;
 
   // RIFF header.
@@ -162,7 +167,7 @@ static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
   }
 
   // Alpha.
-  if (enc->has_alpha_) {
+  if (enc->has_alpha) {
     err = PutAlphaChunk(enc);
     if (err != VP8_ENC_OK) goto Error;
   }
@@ -172,7 +177,7 @@ static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
   if (err != VP8_ENC_OK) goto Error;
 
   // VP8 frame header.
-  err = PutVP8FrameHeader(pic, enc->profile_, size0);
+  err = PutVP8FrameHeader(pic, enc->profile, size0);
   if (err != VP8_ENC_OK) goto Error;
 
   // All OK.
@@ -186,27 +191,27 @@ static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
 // Segmentation header
 static void PutSegmentHeader(VP8BitWriter* const bw,
                              const VP8Encoder* const enc) {
-  const VP8EncSegmentHeader* const hdr = &enc->segment_hdr_;
-  const VP8EncProba* const proba = &enc->proba_;
-  if (VP8PutBitUniform(bw, (hdr->num_segments_ > 1))) {
+  const VP8EncSegmentHeader* const hdr = &enc->segment_hdr;
+  const VP8EncProba* const proba = &enc->proba;
+  if (VP8PutBitUniform(bw, (hdr->num_segments > 1))) {
     // We always 'update' the quant and filter strength values
     const int update_data = 1;
     int s;
-    VP8PutBitUniform(bw, hdr->update_map_);
+    VP8PutBitUniform(bw, hdr->update_map);
     if (VP8PutBitUniform(bw, update_data)) {
       // we always use absolute values, not relative ones
       VP8PutBitUniform(bw, 1);   // (segment_feature_mode = 1. Paragraph 9.3.)
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        VP8PutSignedBits(bw, enc->dqm_[s].quant_, 7);
+        VP8PutSignedBits(bw, enc->dqm[s].quant, 7);
       }
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        VP8PutSignedBits(bw, enc->dqm_[s].fstrength_, 6);
+        VP8PutSignedBits(bw, enc->dqm[s].fstrength, 6);
       }
     }
-    if (hdr->update_map_) {
+    if (hdr->update_map) {
       for (s = 0; s < 3; ++s) {
-        if (VP8PutBitUniform(bw, (proba->segments_[s] != 255u))) {
-          VP8PutBits(bw, proba->segments_[s], 8);
+        if (VP8PutBitUniform(bw, (proba->segments[s] != 255u))) {
+          VP8PutBits(bw, proba->segments[s], 8);
         }
       }
     }
@@ -216,18 +221,18 @@ static void PutSegmentHeader(VP8BitWriter* const bw,
 // Filtering parameters header
 static void PutFilterHeader(VP8BitWriter* const bw,
                             const VP8EncFilterHeader* const hdr) {
-  const int use_lf_delta = (hdr->i4x4_lf_delta_ != 0);
-  VP8PutBitUniform(bw, hdr->simple_);
-  VP8PutBits(bw, hdr->level_, 6);
-  VP8PutBits(bw, hdr->sharpness_, 3);
+  const int use_lf_delta = (hdr->i4x4_lf_delta != 0);
+  VP8PutBitUniform(bw, hdr->simple);
+  VP8PutBits(bw, hdr->level, 6);
+  VP8PutBits(bw, hdr->sharpness, 3);
   if (VP8PutBitUniform(bw, use_lf_delta)) {
-    // '0' is the default value for i4x4_lf_delta_ at frame #0.
-    const int need_update = (hdr->i4x4_lf_delta_ != 0);
+    // '0' is the default value for i4x4_lf_delta at frame #0.
+    const int need_update = (hdr->i4x4_lf_delta != 0);
     if (VP8PutBitUniform(bw, need_update)) {
       // we don't use ref_lf_delta => emit four 0 bits
       VP8PutBits(bw, 0, 4);
       // we use mode_lf_delta for i4x4
-      VP8PutSignedBits(bw, hdr->i4x4_lf_delta_, 6);
+      VP8PutSignedBits(bw, hdr->i4x4_lf_delta, 6);
       VP8PutBits(bw, 0, 3);    // all others unused
     }
   }
@@ -236,12 +241,12 @@ static void PutFilterHeader(VP8BitWriter* const bw,
 // Nominal quantization parameters
 static void PutQuant(VP8BitWriter* const bw,
                      const VP8Encoder* const enc) {
-  VP8PutBits(bw, enc->base_quant_, 7);
-  VP8PutSignedBits(bw, enc->dq_y1_dc_, 4);
-  VP8PutSignedBits(bw, enc->dq_y2_dc_, 4);
-  VP8PutSignedBits(bw, enc->dq_y2_ac_, 4);
-  VP8PutSignedBits(bw, enc->dq_uv_dc_, 4);
-  VP8PutSignedBits(bw, enc->dq_uv_ac_, 4);
+  VP8PutBits(bw, enc->base_quant, 7);
+  VP8PutSignedBits(bw, enc->dq_y1_dc, 4);
+  VP8PutSignedBits(bw, enc->dq_y2_dc, 4);
+  VP8PutSignedBits(bw, enc->dq_y2_ac, 4);
+  VP8PutSignedBits(bw, enc->dq_uv_dc, 4);
+  VP8PutSignedBits(bw, enc->dq_uv_ac, 4);
 }
 
 // Partition sizes
@@ -249,8 +254,8 @@ static int EmitPartitionsSize(const VP8Encoder* const enc,
                               WebPPicture* const pic) {
   uint8_t buf[3 * (MAX_NUM_PARTITIONS - 1)];
   int p;
-  for (p = 0; p < enc->num_parts_ - 1; ++p) {
-    const size_t part_size = VP8BitWriterSize(enc->parts_ + p);
+  for (p = 0; p < enc->num_parts - 1; ++p) {
+    const size_t part_size = VP8BitWriterSize(enc->parts + p);
     if (part_size >= VP8_MAX_PARTITION_SIZE) {
       return WebPEncodingSetError(pic, VP8_ENC_ERROR_PARTITION_OVERFLOW);
     }
@@ -267,25 +272,25 @@ static int EmitPartitionsSize(const VP8Encoder* const enc,
 //------------------------------------------------------------------------------
 
 static int GeneratePartition0(VP8Encoder* const enc) {
-  VP8BitWriter* const bw = &enc->bw_;
-  const int mb_size = enc->mb_w_ * enc->mb_h_;
+  VP8BitWriter* const bw = &enc->bw;
+  const int mb_size = enc->mb_w * enc->mb_h;
   uint64_t pos1, pos2, pos3;
 
   pos1 = VP8BitWriterPos(bw);
   if (!VP8BitWriterInit(bw, mb_size * 7 / 8)) {        // ~7 bits per macroblock
-    return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
+    return WebPEncodingSetError(enc->pic, VP8_ENC_ERROR_OUT_OF_MEMORY);
   }
   VP8PutBitUniform(bw, 0);   // colorspace
   VP8PutBitUniform(bw, 0);   // clamp type
 
   PutSegmentHeader(bw, enc);
-  PutFilterHeader(bw, &enc->filter_hdr_);
-  VP8PutBits(bw, enc->num_parts_ == 8 ? 3 :
-                 enc->num_parts_ == 4 ? 2 :
-                 enc->num_parts_ == 2 ? 1 : 0, 2);
+  PutFilterHeader(bw, &enc->filter_hdr);
+  VP8PutBits(bw, enc->num_parts == 8 ? 3 :
+                 enc->num_parts == 4 ? 2 :
+                 enc->num_parts == 2 ? 1 : 0, 2);
   PutQuant(bw, enc);
   VP8PutBitUniform(bw, 0);   // no proba update
-  VP8WriteProbas(bw, &enc->proba_);
+  VP8WriteProbas(bw, &enc->proba);
   pos2 = VP8BitWriterPos(bw);
   VP8CodeIntraModes(enc);
   VP8BitWriterFinish(bw);
@@ -293,36 +298,36 @@ static int GeneratePartition0(VP8Encoder* const enc) {
   pos3 = VP8BitWriterPos(bw);
 
 #if !defined(WEBP_DISABLE_STATS)
-  if (enc->pic_->stats) {
-    enc->pic_->stats->header_bytes[0] = (int)((pos2 - pos1 + 7) >> 3);
-    enc->pic_->stats->header_bytes[1] = (int)((pos3 - pos2 + 7) >> 3);
-    enc->pic_->stats->alpha_data_size = (int)enc->alpha_data_size_;
+  if (enc->pic->stats) {
+    enc->pic->stats->header_bytes[0] = (int)((pos2 - pos1 + 7) >> 3);
+    enc->pic->stats->header_bytes[1] = (int)((pos3 - pos2 + 7) >> 3);
+    enc->pic->stats->alpha_data_size = (int)enc->alpha_data_size;
   }
 #else
   (void)pos1;
   (void)pos2;
   (void)pos3;
 #endif
-  if (bw->error_) {
-    return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
+  if (bw->error) {
+    return WebPEncodingSetError(enc->pic, VP8_ENC_ERROR_OUT_OF_MEMORY);
   }
   return 1;
 }
 
 void VP8EncFreeBitWriters(VP8Encoder* const enc) {
   int p;
-  VP8BitWriterWipeOut(&enc->bw_);
-  for (p = 0; p < enc->num_parts_; ++p) {
-    VP8BitWriterWipeOut(enc->parts_ + p);
+  VP8BitWriterWipeOut(&enc->bw);
+  for (p = 0; p < enc->num_parts; ++p) {
+    VP8BitWriterWipeOut(enc->parts + p);
   }
 }
 
 int VP8EncWrite(VP8Encoder* const enc) {
-  WebPPicture* const pic = enc->pic_;
-  VP8BitWriter* const bw = &enc->bw_;
+  WebPPicture* const pic = enc->pic;
+  VP8BitWriter* const bw = &enc->bw;
   const int task_percent = 19;
-  const int percent_per_part = task_percent / enc->num_parts_;
-  const int final_percent = enc->percent_ + task_percent;
+  const int percent_per_part = task_percent / enc->num_parts;
+  const int final_percent = enc->percent + task_percent;
   int ok = 0;
   size_t vp8_size, pad, riff_size;
   int p;
@@ -334,9 +339,9 @@ int VP8EncWrite(VP8Encoder* const enc) {
   // Compute VP8 size
   vp8_size = VP8_FRAME_HEADER_SIZE +
              VP8BitWriterSize(bw) +
-             3 * (enc->num_parts_ - 1);
-  for (p = 0; p < enc->num_parts_; ++p) {
-    vp8_size += VP8BitWriterSize(enc->parts_ + p);
+             3 * (enc->num_parts - 1);
+  for (p = 0; p < enc->num_parts; ++p) {
+    vp8_size += VP8BitWriterSize(enc->parts + p);
   }
   pad = vp8_size & 1;
   vp8_size += pad;
@@ -347,9 +352,9 @@ int VP8EncWrite(VP8Encoder* const enc) {
   if (IsVP8XNeeded(enc)) {  // Add size for: VP8X header + data.
     riff_size += CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
   }
-  if (enc->has_alpha_) {  // Add size for: ALPH header + data.
-    const uint32_t padded_alpha_size = enc->alpha_data_size_ +
-                                       (enc->alpha_data_size_ & 1);
+  if (enc->has_alpha) {  // Add size for: ALPH header + data.
+    const uint32_t padded_alpha_size = enc->alpha_data_size +
+                                       (enc->alpha_data_size & 1);
     riff_size += CHUNK_HEADER_SIZE + padded_alpha_size;
   }
   // RIFF size should fit in 32-bits.
@@ -368,13 +373,13 @@ int VP8EncWrite(VP8Encoder* const enc) {
   }
 
   // Token partitions
-  for (p = 0; p < enc->num_parts_; ++p) {
-    const uint8_t* const buf = VP8BitWriterBuf(enc->parts_ + p);
-    const size_t size = VP8BitWriterSize(enc->parts_ + p);
+  for (p = 0; p < enc->num_parts; ++p) {
+    const uint8_t* const buf = VP8BitWriterBuf(enc->parts + p);
+    const size_t size = VP8BitWriterSize(enc->parts + p);
     if (size) ok = ok && pic->writer(buf, size, pic);
-    VP8BitWriterWipeOut(enc->parts_ + p);    // will free the internal buffer.
-    ok = ok && WebPReportProgress(pic, enc->percent_ + percent_per_part,
-                                  &enc->percent_);
+    VP8BitWriterWipeOut(enc->parts + p);    // will free the internal buffer.
+    ok = ok && WebPReportProgress(pic, enc->percent + percent_per_part,
+                                  &enc->percent);
   }
 
   // Padding byte
@@ -382,11 +387,10 @@ int VP8EncWrite(VP8Encoder* const enc) {
     ok = PutPaddingByte(pic);
   }
 
-  enc->coded_size_ = (int)(CHUNK_HEADER_SIZE + riff_size);
-  ok = ok && WebPReportProgress(pic, final_percent, &enc->percent_);
+  enc->coded_size = (int)(CHUNK_HEADER_SIZE + riff_size);
+  ok = ok && WebPReportProgress(pic, final_percent, &enc->percent);
   if (!ok) WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_WRITE);
   return ok;
 }
 
 //------------------------------------------------------------------------------
-