Coverage Report

Created: 2024-07-27 06:27

/src/libwebp/src/enc/webp_enc.c
Line
Count
Source (jump to first uncovered line)
1
// Copyright 2011 Google Inc. All Rights Reserved.
2
//
3
// Use of this source code is governed by a BSD-style license
4
// that can be found in the COPYING file in the root of the source
5
// tree. An additional intellectual property rights grant can be found
6
// in the file PATENTS. All contributing project authors may
7
// be found in the AUTHORS file in the root of the source tree.
8
// -----------------------------------------------------------------------------
9
//
10
// WebP encoder: main entry point
11
//
12
// Author: Skal (pascal.massimino@gmail.com)
13
14
#include <assert.h>
15
#include <stdlib.h>
16
#include <string.h>
17
#include <math.h>
18
19
#include "src/enc/cost_enc.h"
20
#include "src/enc/vp8i_enc.h"
21
#include "src/enc/vp8li_enc.h"
22
#include "src/utils/utils.h"
23
24
// #define PRINT_MEMORY_INFO
25
26
#ifdef PRINT_MEMORY_INFO
27
#include <stdio.h>
28
#endif
29
30
//------------------------------------------------------------------------------
31
32
0
int WebPGetEncoderVersion(void) {
33
0
  return (ENC_MAJ_VERSION << 16) | (ENC_MIN_VERSION << 8) | ENC_REV_VERSION;
34
0
}
35
36
//------------------------------------------------------------------------------
37
// VP8Encoder
38
//------------------------------------------------------------------------------
39
40
0
static void ResetSegmentHeader(VP8Encoder* const enc) {
41
0
  VP8EncSegmentHeader* const hdr = &enc->segment_hdr_;
42
0
  hdr->num_segments_ = enc->config_->segments;
43
0
  hdr->update_map_  = (hdr->num_segments_ > 1);
44
0
  hdr->size_ = 0;
45
0
}
46
47
0
static void ResetFilterHeader(VP8Encoder* const enc) {
48
0
  VP8EncFilterHeader* const hdr = &enc->filter_hdr_;
49
0
  hdr->simple_ = 1;
50
0
  hdr->level_ = 0;
51
0
  hdr->sharpness_ = 0;
52
0
  hdr->i4x4_lf_delta_ = 0;
53
0
}
54
55
0
static void ResetBoundaryPredictions(VP8Encoder* const enc) {
56
  // init boundary values once for all
57
  // Note: actually, initializing the preds_[] is only needed for intra4.
58
0
  int i;
59
0
  uint8_t* const top = enc->preds_ - enc->preds_w_;
60
0
  uint8_t* const left = enc->preds_ - 1;
61
0
  for (i = -1; i < 4 * enc->mb_w_; ++i) {
62
0
    top[i] = B_DC_PRED;
63
0
  }
64
0
  for (i = 0; i < 4 * enc->mb_h_; ++i) {
65
0
    left[i * enc->preds_w_] = B_DC_PRED;
66
0
  }
67
0
  enc->nz_[-1] = 0;   // constant
68
0
}
69
70
// Mapping from config->method_ to coding tools used.
71
//-------------------+---+---+---+---+---+---+---+
72
//   Method          | 0 | 1 | 2 | 3 |(4)| 5 | 6 |
73
//-------------------+---+---+---+---+---+---+---+
74
// fast probe        | x |   |   | x |   |   |   |
75
//-------------------+---+---+---+---+---+---+---+
76
// dynamic proba     | ~ | x | x | x | x | x | x |
77
//-------------------+---+---+---+---+---+---+---+
78
// fast mode analysis|[x]|[x]|   |   | x | x | x |
79
//-------------------+---+---+---+---+---+---+---+
80
// basic rd-opt      |   |   |   | x | x | x | x |
81
//-------------------+---+---+---+---+---+---+---+
82
// disto-refine i4/16| x | x | x |   |   |   |   |
83
//-------------------+---+---+---+---+---+---+---+
84
// disto-refine uv   |   | x | x |   |   |   |   |
85
//-------------------+---+---+---+---+---+---+---+
86
// rd-opt i4/16      |   |   | ~ | x | x | x | x |
87
//-------------------+---+---+---+---+---+---+---+
88
// token buffer (opt)|   |   |   | x | x | x | x |
89
//-------------------+---+---+---+---+---+---+---+
90
// Trellis           |   |   |   |   |   | x |Ful|
91
//-------------------+---+---+---+---+---+---+---+
92
// full-SNS          |   |   |   |   | x | x | x |
93
//-------------------+---+---+---+---+---+---+---+
94
95
0
static void MapConfigToTools(VP8Encoder* const enc) {
96
0
  const WebPConfig* const config = enc->config_;
97
0
  const int method = config->method;
98
0
  const int limit = 100 - config->partition_limit;
99
0
  enc->method_ = method;
100
0
  enc->rd_opt_level_ = (method >= 6) ? RD_OPT_TRELLIS_ALL
101
0
                     : (method >= 5) ? RD_OPT_TRELLIS
102
0
                     : (method >= 3) ? RD_OPT_BASIC
103
0
                     : RD_OPT_NONE;
104
0
  enc->max_i4_header_bits_ =
105
0
      256 * 16 * 16 *                 // upper bound: up to 16bit per 4x4 block
106
0
      (limit * limit) / (100 * 100);  // ... modulated with a quadratic curve.
107
108
  // partition0 = 512k max.
109
0
  enc->mb_header_limit_ =
110
0
      (score_t)256 * 510 * 8 * 1024 / (enc->mb_w_ * enc->mb_h_);
111
112
0
  enc->thread_level_ = config->thread_level;
113
114
0
  enc->do_search_ = (config->target_size > 0 || config->target_PSNR > 0);
115
0
  if (!config->low_memory) {
116
0
#if !defined(DISABLE_TOKEN_BUFFER)
117
0
    enc->use_tokens_ = (enc->rd_opt_level_ >= RD_OPT_BASIC);  // need rd stats
118
0
#endif
119
0
    if (enc->use_tokens_) {
120
0
      enc->num_parts_ = 1;   // doesn't work with multi-partition
121
0
    }
122
0
  }
123
0
}
124
125
// Memory scaling with dimensions:
126
//  memory (bytes) ~= 2.25 * w + 0.0625 * w * h
127
//
128
// Typical memory footprint (614x440 picture)
129
//              encoder: 22111
130
//                 info: 4368
131
//                preds: 17741
132
//          top samples: 1263
133
//             non-zero: 175
134
//             lf-stats: 0
135
//                total: 45658
136
// Transient object sizes:
137
//       VP8EncIterator: 3360
138
//         VP8ModeScore: 872
139
//       VP8SegmentInfo: 732
140
//          VP8EncProba: 18352
141
//              LFStats: 2048
142
// Picture size (yuv): 419328
143
144
static VP8Encoder* InitVP8Encoder(const WebPConfig* const config,
145
0
                                  WebPPicture* const picture) {
146
0
  VP8Encoder* enc;
147
0
  const int use_filter =
148
0
      (config->filter_strength > 0) || (config->autofilter > 0);
149
0
  const int mb_w = (picture->width + 15) >> 4;
150
0
  const int mb_h = (picture->height + 15) >> 4;
151
0
  const int preds_w = 4 * mb_w + 1;
152
0
  const int preds_h = 4 * mb_h + 1;
153
0
  const size_t preds_size = preds_w * preds_h * sizeof(*enc->preds_);
154
0
  const int top_stride = mb_w * 16;
155
0
  const size_t nz_size = (mb_w + 1) * sizeof(*enc->nz_) + WEBP_ALIGN_CST;
156
0
  const size_t info_size = mb_w * mb_h * sizeof(*enc->mb_info_);
157
0
  const size_t samples_size =
158
0
      2 * top_stride * sizeof(*enc->y_top_)  // top-luma/u/v
159
0
      + WEBP_ALIGN_CST;                      // align all
160
0
  const size_t lf_stats_size =
161
0
      config->autofilter ? sizeof(*enc->lf_stats_) + WEBP_ALIGN_CST : 0;
162
0
  const size_t top_derr_size =
163
0
      (config->quality <= ERROR_DIFFUSION_QUALITY || config->pass > 1) ?
164
0
          mb_w * sizeof(*enc->top_derr_) : 0;
165
0
  uint8_t* mem;
166
0
  const uint64_t size = (uint64_t)sizeof(*enc)   // main struct
167
                      + WEBP_ALIGN_CST           // cache alignment
168
0
                      + info_size                // modes info
169
0
                      + preds_size               // prediction modes
170
0
                      + samples_size             // top/left samples
171
0
                      + top_derr_size            // top diffusion error
172
0
                      + nz_size                  // coeff context bits
173
0
                      + lf_stats_size;           // autofilter stats
174
175
#ifdef PRINT_MEMORY_INFO
176
  printf("===================================\n");
177
  printf("Memory used:\n"
178
         "             encoder: %ld\n"
179
         "                info: %ld\n"
180
         "               preds: %ld\n"
181
         "         top samples: %ld\n"
182
         "       top diffusion: %ld\n"
183
         "            non-zero: %ld\n"
184
         "            lf-stats: %ld\n"
185
         "               total: %ld\n",
186
         sizeof(*enc) + WEBP_ALIGN_CST, info_size,
187
         preds_size, samples_size, top_derr_size, nz_size, lf_stats_size, size);
188
  printf("Transient object sizes:\n"
189
         "      VP8EncIterator: %ld\n"
190
         "        VP8ModeScore: %ld\n"
191
         "      VP8SegmentInfo: %ld\n"
192
         "         VP8EncProba: %ld\n"
193
         "             LFStats: %ld\n",
194
         sizeof(VP8EncIterator), sizeof(VP8ModeScore),
195
         sizeof(VP8SegmentInfo), sizeof(VP8EncProba),
196
         sizeof(LFStats));
197
  printf("Picture size (yuv): %ld\n",
198
         mb_w * mb_h * 384 * sizeof(uint8_t));
199
  printf("===================================\n");
200
#endif
201
0
  mem = (uint8_t*)WebPSafeMalloc(size, sizeof(*mem));
202
0
  if (mem == NULL) {
203
0
    WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
204
0
    return NULL;
205
0
  }
206
0
  enc = (VP8Encoder*)mem;
207
0
  mem = (uint8_t*)WEBP_ALIGN(mem + sizeof(*enc));
208
0
  memset(enc, 0, sizeof(*enc));
209
0
  enc->num_parts_ = 1 << config->partitions;
210
0
  enc->mb_w_ = mb_w;
211
0
  enc->mb_h_ = mb_h;
212
0
  enc->preds_w_ = preds_w;
213
0
  enc->mb_info_ = (VP8MBInfo*)mem;
214
0
  mem += info_size;
215
0
  enc->preds_ = mem + 1 + enc->preds_w_;
216
0
  mem += preds_size;
217
0
  enc->nz_ = 1 + (uint32_t*)WEBP_ALIGN(mem);
218
0
  mem += nz_size;
219
0
  enc->lf_stats_ = lf_stats_size ? (LFStats*)WEBP_ALIGN(mem) : NULL;
220
0
  mem += lf_stats_size;
221
222
  // top samples (all 16-aligned)
223
0
  mem = (uint8_t*)WEBP_ALIGN(mem);
224
0
  enc->y_top_ = mem;
225
0
  enc->uv_top_ = enc->y_top_ + top_stride;
226
0
  mem += 2 * top_stride;
227
0
  enc->top_derr_ = top_derr_size ? (DError*)mem : NULL;
228
0
  mem += top_derr_size;
229
0
  assert(mem <= (uint8_t*)enc + size);
230
231
0
  enc->config_ = config;
232
0
  enc->profile_ = use_filter ? ((config->filter_type == 1) ? 0 : 1) : 2;
233
0
  enc->pic_ = picture;
234
0
  enc->percent_ = 0;
235
236
0
  MapConfigToTools(enc);
237
0
  VP8EncDspInit();
238
0
  VP8DefaultProbas(enc);
239
0
  ResetSegmentHeader(enc);
240
0
  ResetFilterHeader(enc);
241
0
  ResetBoundaryPredictions(enc);
242
0
  VP8EncDspCostInit();
243
0
  VP8EncInitAlpha(enc);
244
245
  // lower quality means smaller output -> we modulate a little the page
246
  // size based on quality. This is just a crude 1rst-order prediction.
247
0
  {
248
0
    const float scale = 1.f + config->quality * 5.f / 100.f;  // in [1,6]
249
0
    VP8TBufferInit(&enc->tokens_, (int)(mb_w * mb_h * 4 * scale));
250
0
  }
251
0
  return enc;
252
0
}
253
254
0
static int DeleteVP8Encoder(VP8Encoder* enc) {
255
0
  int ok = 1;
256
0
  if (enc != NULL) {
257
0
    ok = VP8EncDeleteAlpha(enc);
258
0
    VP8TBufferClear(&enc->tokens_);
259
0
    WebPSafeFree(enc);
260
0
  }
261
0
  return ok;
262
0
}
263
264
//------------------------------------------------------------------------------
265
266
#if !defined(WEBP_DISABLE_STATS)
267
0
static double GetPSNR(uint64_t err, uint64_t size) {
268
0
  return (err > 0 && size > 0) ? 10. * log10(255. * 255. * size / err) : 99.;
269
0
}
270
271
0
static void FinalizePSNR(const VP8Encoder* const enc) {
272
0
  WebPAuxStats* stats = enc->pic_->stats;
273
0
  const uint64_t size = enc->sse_count_;
274
0
  const uint64_t* const sse = enc->sse_;
275
0
  stats->PSNR[0] = (float)GetPSNR(sse[0], size);
276
0
  stats->PSNR[1] = (float)GetPSNR(sse[1], size / 4);
277
0
  stats->PSNR[2] = (float)GetPSNR(sse[2], size / 4);
278
0
  stats->PSNR[3] = (float)GetPSNR(sse[0] + sse[1] + sse[2], size * 3 / 2);
279
0
  stats->PSNR[4] = (float)GetPSNR(sse[3], size);
280
0
}
281
#endif  // !defined(WEBP_DISABLE_STATS)
282
283
0
static void StoreStats(VP8Encoder* const enc) {
284
0
#if !defined(WEBP_DISABLE_STATS)
285
0
  WebPAuxStats* const stats = enc->pic_->stats;
286
0
  if (stats != NULL) {
287
0
    int i, s;
288
0
    for (i = 0; i < NUM_MB_SEGMENTS; ++i) {
289
0
      stats->segment_level[i] = enc->dqm_[i].fstrength_;
290
0
      stats->segment_quant[i] = enc->dqm_[i].quant_;
291
0
      for (s = 0; s <= 2; ++s) {
292
0
        stats->residual_bytes[s][i] = enc->residual_bytes_[s][i];
293
0
      }
294
0
    }
295
0
    FinalizePSNR(enc);
296
0
    stats->coded_size = enc->coded_size_;
297
0
    for (i = 0; i < 3; ++i) {
298
0
      stats->block_count[i] = enc->block_count_[i];
299
0
    }
300
0
  }
301
#else  // defined(WEBP_DISABLE_STATS)
302
  WebPReportProgress(enc->pic_, 100, &enc->percent_);  // done!
303
#endif  // !defined(WEBP_DISABLE_STATS)
304
0
}
305
306
int WebPEncodingSetError(const WebPPicture* const pic,
307
0
                         WebPEncodingError error) {
308
0
  assert((int)error < VP8_ENC_ERROR_LAST);
309
0
  assert((int)error >= VP8_ENC_OK);
310
  // The oldest error reported takes precedence over the new one.
311
0
  if (pic->error_code == VP8_ENC_OK) {
312
0
    ((WebPPicture*)pic)->error_code = error;
313
0
  }
314
0
  return 0;
315
0
}
316
317
int WebPReportProgress(const WebPPicture* const pic,
318
0
                       int percent, int* const percent_store) {
319
0
  if (percent_store != NULL && percent != *percent_store) {
320
0
    *percent_store = percent;
321
0
    if (pic->progress_hook && !pic->progress_hook(percent, pic)) {
322
      // user abort requested
323
0
      return WebPEncodingSetError(pic, VP8_ENC_ERROR_USER_ABORT);
324
0
    }
325
0
  }
326
0
  return 1;  // ok
327
0
}
328
//------------------------------------------------------------------------------
329
330
0
int WebPEncode(const WebPConfig* config, WebPPicture* pic) {
331
0
  int ok = 0;
332
0
  if (pic == NULL) return 0;
333
334
0
  pic->error_code = VP8_ENC_OK;  // all ok so far
335
0
  if (config == NULL) {  // bad params
336
0
    return WebPEncodingSetError(pic, VP8_ENC_ERROR_NULL_PARAMETER);
337
0
  }
338
0
  if (!WebPValidateConfig(config)) {
339
0
    return WebPEncodingSetError(pic, VP8_ENC_ERROR_INVALID_CONFIGURATION);
340
0
  }
341
0
  if (!WebPValidatePicture(pic)) return 0;
342
0
  if (pic->width > WEBP_MAX_DIMENSION || pic->height > WEBP_MAX_DIMENSION) {
343
0
    return WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_DIMENSION);
344
0
  }
345
346
0
  if (pic->stats != NULL) memset(pic->stats, 0, sizeof(*pic->stats));
347
348
0
  if (!config->lossless) {
349
0
    VP8Encoder* enc = NULL;
350
351
0
    if (pic->use_argb || pic->y == NULL || pic->u == NULL || pic->v == NULL) {
352
      // Make sure we have YUVA samples.
353
0
      if (config->use_sharp_yuv || (config->preprocessing & 4)) {
354
0
        if (!WebPPictureSharpARGBToYUVA(pic)) {
355
0
          return 0;
356
0
        }
357
0
      } else {
358
0
        float dithering = 0.f;
359
0
        if (config->preprocessing & 2) {
360
0
          const float x = config->quality / 100.f;
361
0
          const float x2 = x * x;
362
          // slowly decreasing from max dithering at low quality (q->0)
363
          // to 0.5 dithering amplitude at high quality (q->100)
364
0
          dithering = 1.0f + (0.5f - 1.0f) * x2 * x2;
365
0
        }
366
0
        if (!WebPPictureARGBToYUVADithered(pic, WEBP_YUV420, dithering)) {
367
0
          return 0;
368
0
        }
369
0
      }
370
0
    }
371
372
0
    if (!config->exact) {
373
0
      WebPCleanupTransparentArea(pic);
374
0
    }
375
376
0
    enc = InitVP8Encoder(config, pic);
377
0
    if (enc == NULL) return 0;  // pic->error is already set.
378
    // Note: each of the tasks below account for 20% in the progress report.
379
0
    ok = VP8EncAnalyze(enc);
380
381
    // Analysis is done, proceed to actual coding.
382
0
    ok = ok && VP8EncStartAlpha(enc);   // possibly done in parallel
383
0
    if (!enc->use_tokens_) {
384
0
      ok = ok && VP8EncLoop(enc);
385
0
    } else {
386
0
      ok = ok && VP8EncTokenLoop(enc);
387
0
    }
388
0
    ok = ok && VP8EncFinishAlpha(enc);
389
390
0
    ok = ok && VP8EncWrite(enc);
391
0
    StoreStats(enc);
392
0
    if (!ok) {
393
0
      VP8EncFreeBitWriters(enc);
394
0
    }
395
0
    ok &= DeleteVP8Encoder(enc);  // must always be called, even if !ok
396
0
  } else {
397
    // Make sure we have ARGB samples.
398
0
    if (pic->argb == NULL && !WebPPictureYUVAToARGB(pic)) {
399
0
      return 0;
400
0
    }
401
402
0
    if (!config->exact) {
403
0
      WebPReplaceTransparentPixels(pic, 0x000000);
404
0
    }
405
406
0
    ok = VP8LEncodeImage(config, pic);  // Sets pic->error in case of problem.
407
0
  }
408
409
0
  return ok;
410
0
}