/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 | } |