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// Header syntax writing
11//
12// Author: Skal (pascal.massimino@gmail.com)
13
14#include <assert.h>
15
16#include "src/utils/utils.h"
17#include "src/webp/format_constants.h" // RIFF constants
18#include "src/webp/mux_types.h" // ALPHA_FLAG
19#include "src/enc/vp8i_enc.h"
20
21//------------------------------------------------------------------------------
22// Helper functions
23
24static int IsVP8XNeeded(const VP8Encoder* const enc) {
25 return !!enc->has_alpha_; // Currently the only case when VP8X is needed.
26 // This could change in the future.
27}
28
29static int PutPaddingByte(const WebPPicture* const pic) {
30 const uint8_t pad_byte[1] = { 0 };
31 return !!pic->writer(pad_byte, 1, pic);
32}
33
34//------------------------------------------------------------------------------
35// Writers for header's various pieces (in order of appearance)
36
37static WebPEncodingError PutRIFFHeader(const VP8Encoder* const enc,
38 size_t riff_size) {
39 const WebPPicture* const pic = enc->pic_;
40 uint8_t riff[RIFF_HEADER_SIZE] = {
41 'R', 'I', 'F', 'F', 0, 0, 0, 0, 'W', 'E', 'B', 'P'
42 };
43 assert(riff_size == (uint32_t)riff_size);
44 PutLE32(riff + TAG_SIZE, (uint32_t)riff_size);
45 if (!pic->writer(riff, sizeof(riff), pic)) {
46 return VP8_ENC_ERROR_BAD_WRITE;
47 }
48 return VP8_ENC_OK;
49}
50
51static WebPEncodingError PutVP8XHeader(const VP8Encoder* const enc) {
52 const WebPPicture* const pic = enc->pic_;
53 uint8_t vp8x[CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE] = {
54 'V', 'P', '8', 'X'
55 };
56 uint32_t flags = 0;
57
58 assert(IsVP8XNeeded(enc));
59 assert(pic->width >= 1 && pic->height >= 1);
60 assert(pic->width <= MAX_CANVAS_SIZE && pic->height <= MAX_CANVAS_SIZE);
61
62 if (enc->has_alpha_) {
63 flags |= ALPHA_FLAG;
64 }
65
66 PutLE32(vp8x + TAG_SIZE, VP8X_CHUNK_SIZE);
67 PutLE32(vp8x + CHUNK_HEADER_SIZE, flags);
68 PutLE24(vp8x + CHUNK_HEADER_SIZE + 4, pic->width - 1);
69 PutLE24(vp8x + CHUNK_HEADER_SIZE + 7, pic->height - 1);
70 if (!pic->writer(vp8x, sizeof(vp8x), pic)) {
71 return VP8_ENC_ERROR_BAD_WRITE;
72 }
73 return VP8_ENC_OK;
74}
75
76static WebPEncodingError PutAlphaChunk(const VP8Encoder* const enc) {
77 const WebPPicture* const pic = enc->pic_;
78 uint8_t alpha_chunk_hdr[CHUNK_HEADER_SIZE] = {
79 'A', 'L', 'P', 'H'
80 };
81
82 assert(enc->has_alpha_);
83
84 // Alpha chunk header.
85 PutLE32(alpha_chunk_hdr + TAG_SIZE, enc->alpha_data_size_);
86 if (!pic->writer(alpha_chunk_hdr, sizeof(alpha_chunk_hdr), pic)) {
87 return VP8_ENC_ERROR_BAD_WRITE;
88 }
89
90 // Alpha chunk data.
91 if (!pic->writer(enc->alpha_data_, enc->alpha_data_size_, pic)) {
92 return VP8_ENC_ERROR_BAD_WRITE;
93 }
94
95 // Padding.
96 if ((enc->alpha_data_size_ & 1) && !PutPaddingByte(pic)) {
97 return VP8_ENC_ERROR_BAD_WRITE;
98 }
99 return VP8_ENC_OK;
100}
101
102static WebPEncodingError PutVP8Header(const WebPPicture* const pic,
103 size_t vp8_size) {
104 uint8_t vp8_chunk_hdr[CHUNK_HEADER_SIZE] = {
105 'V', 'P', '8', ' '
106 };
107 assert(vp8_size == (uint32_t)vp8_size);
108 PutLE32(vp8_chunk_hdr + TAG_SIZE, (uint32_t)vp8_size);
109 if (!pic->writer(vp8_chunk_hdr, sizeof(vp8_chunk_hdr), pic)) {
110 return VP8_ENC_ERROR_BAD_WRITE;
111 }
112 return VP8_ENC_OK;
113}
114
115static WebPEncodingError PutVP8FrameHeader(const WebPPicture* const pic,
116 int profile, size_t size0) {
117 uint8_t vp8_frm_hdr[VP8_FRAME_HEADER_SIZE];
118 uint32_t bits;
119
120 if (size0 >= VP8_MAX_PARTITION0_SIZE) { // partition #0 is too big to fit
121 return VP8_ENC_ERROR_PARTITION0_OVERFLOW;
122 }
123
124 // Paragraph 9.1.
125 bits = 0 // keyframe (1b)
126 | (profile << 1) // profile (3b)
127 | (1 << 4) // visible (1b)
128 | ((uint32_t)size0 << 5); // partition length (19b)
129 vp8_frm_hdr[0] = (bits >> 0) & 0xff;
130 vp8_frm_hdr[1] = (bits >> 8) & 0xff;
131 vp8_frm_hdr[2] = (bits >> 16) & 0xff;
132 // signature
133 vp8_frm_hdr[3] = (VP8_SIGNATURE >> 16) & 0xff;
134 vp8_frm_hdr[4] = (VP8_SIGNATURE >> 8) & 0xff;
135 vp8_frm_hdr[5] = (VP8_SIGNATURE >> 0) & 0xff;
136 // dimensions
137 vp8_frm_hdr[6] = pic->width & 0xff;
138 vp8_frm_hdr[7] = pic->width >> 8;
139 vp8_frm_hdr[8] = pic->height & 0xff;
140 vp8_frm_hdr[9] = pic->height >> 8;
141
142 if (!pic->writer(vp8_frm_hdr, sizeof(vp8_frm_hdr), pic)) {
143 return VP8_ENC_ERROR_BAD_WRITE;
144 }
145 return VP8_ENC_OK;
146}
147
148// WebP Headers.
149static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
150 size_t vp8_size, size_t riff_size) {
151 WebPPicture* const pic = enc->pic_;
152 WebPEncodingError err = VP8_ENC_OK;
153
154 // RIFF header.
155 err = PutRIFFHeader(enc, riff_size);
156 if (err != VP8_ENC_OK) goto Error;
157
158 // VP8X.
159 if (IsVP8XNeeded(enc)) {
160 err = PutVP8XHeader(enc);
161 if (err != VP8_ENC_OK) goto Error;
162 }
163
164 // Alpha.
165 if (enc->has_alpha_) {
166 err = PutAlphaChunk(enc);
167 if (err != VP8_ENC_OK) goto Error;
168 }
169
170 // VP8 header.
171 err = PutVP8Header(pic, vp8_size);
172 if (err != VP8_ENC_OK) goto Error;
173
174 // VP8 frame header.
175 err = PutVP8FrameHeader(pic, enc->profile_, size0);
176 if (err != VP8_ENC_OK) goto Error;
177
178 // All OK.
179 return 1;
180
181 // Error.
182 Error:
183 return WebPEncodingSetError(pic, err);
184}
185
186// Segmentation header
187static void PutSegmentHeader(VP8BitWriter* const bw,
188 const VP8Encoder* const enc) {
189 const VP8EncSegmentHeader* const hdr = &enc->segment_hdr_;
190 const VP8EncProba* const proba = &enc->proba_;
191 if (VP8PutBitUniform(bw, (hdr->num_segments_ > 1))) {
192 // We always 'update' the quant and filter strength values
193 const int update_data = 1;
194 int s;
195 VP8PutBitUniform(bw, hdr->update_map_);
196 if (VP8PutBitUniform(bw, update_data)) {
197 // we always use absolute values, not relative ones
198 VP8PutBitUniform(bw, 1); // (segment_feature_mode = 1. Paragraph 9.3.)
199 for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
200 VP8PutSignedBits(bw, enc->dqm_[s].quant_, 7);
201 }
202 for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
203 VP8PutSignedBits(bw, enc->dqm_[s].fstrength_, 6);
204 }
205 }
206 if (hdr->update_map_) {
207 for (s = 0; s < 3; ++s) {
208 if (VP8PutBitUniform(bw, (proba->segments_[s] != 255u))) {
209 VP8PutBits(bw, proba->segments_[s], 8);
210 }
211 }
212 }
213 }
214}
215
216// Filtering parameters header
217static void PutFilterHeader(VP8BitWriter* const bw,
218 const VP8EncFilterHeader* const hdr) {
219 const int use_lf_delta = (hdr->i4x4_lf_delta_ != 0);
220 VP8PutBitUniform(bw, hdr->simple_);
221 VP8PutBits(bw, hdr->level_, 6);
222 VP8PutBits(bw, hdr->sharpness_, 3);
223 if (VP8PutBitUniform(bw, use_lf_delta)) {
224 // '0' is the default value for i4x4_lf_delta_ at frame #0.
225 const int need_update = (hdr->i4x4_lf_delta_ != 0);
226 if (VP8PutBitUniform(bw, need_update)) {
227 // we don't use ref_lf_delta => emit four 0 bits
228 VP8PutBits(bw, 0, 4);
229 // we use mode_lf_delta for i4x4
230 VP8PutSignedBits(bw, hdr->i4x4_lf_delta_, 6);
231 VP8PutBits(bw, 0, 3); // all others unused
232 }
233 }
234}
235
236// Nominal quantization parameters
237static void PutQuant(VP8BitWriter* const bw,
238 const VP8Encoder* const enc) {
239 VP8PutBits(bw, enc->base_quant_, 7);
240 VP8PutSignedBits(bw, enc->dq_y1_dc_, 4);
241 VP8PutSignedBits(bw, enc->dq_y2_dc_, 4);
242 VP8PutSignedBits(bw, enc->dq_y2_ac_, 4);
243 VP8PutSignedBits(bw, enc->dq_uv_dc_, 4);
244 VP8PutSignedBits(bw, enc->dq_uv_ac_, 4);
245}
246
247// Partition sizes
248static int EmitPartitionsSize(const VP8Encoder* const enc,
249 WebPPicture* const pic) {
250 uint8_t buf[3 * (MAX_NUM_PARTITIONS - 1)];
251 int p;
252 for (p = 0; p < enc->num_parts_ - 1; ++p) {
253 const size_t part_size = VP8BitWriterSize(enc->parts_ + p);
254 if (part_size >= VP8_MAX_PARTITION_SIZE) {
255 return WebPEncodingSetError(pic, VP8_ENC_ERROR_PARTITION_OVERFLOW);
256 }
257 buf[3 * p + 0] = (part_size >> 0) & 0xff;
258 buf[3 * p + 1] = (part_size >> 8) & 0xff;
259 buf[3 * p + 2] = (part_size >> 16) & 0xff;
260 }
261 return p ? pic->writer(buf, 3 * p, pic) : 1;
262}
263
264//------------------------------------------------------------------------------
265
266static int GeneratePartition0(VP8Encoder* const enc) {
267 VP8BitWriter* const bw = &enc->bw_;
268 const int mb_size = enc->mb_w_ * enc->mb_h_;
269 uint64_t pos1, pos2, pos3;
270
271 pos1 = VP8BitWriterPos(bw);
272 if (!VP8BitWriterInit(bw, mb_size * 7 / 8)) { // ~7 bits per macroblock
273 return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
274 }
275 VP8PutBitUniform(bw, 0); // colorspace
276 VP8PutBitUniform(bw, 0); // clamp type
277
278 PutSegmentHeader(bw, enc);
279 PutFilterHeader(bw, &enc->filter_hdr_);
280 VP8PutBits(bw, enc->num_parts_ == 8 ? 3 :
281 enc->num_parts_ == 4 ? 2 :
282 enc->num_parts_ == 2 ? 1 : 0, 2);
283 PutQuant(bw, enc);
284 VP8PutBitUniform(bw, 0); // no proba update
285 VP8WriteProbas(bw, &enc->proba_);
286 pos2 = VP8BitWriterPos(bw);
287 VP8CodeIntraModes(enc);
288 VP8BitWriterFinish(bw);
289
290 pos3 = VP8BitWriterPos(bw);
291
292#if !defined(WEBP_DISABLE_STATS)
293 if (enc->pic_->stats) {
294 enc->pic_->stats->header_bytes[0] = (int)((pos2 - pos1 + 7) >> 3);
295 enc->pic_->stats->header_bytes[1] = (int)((pos3 - pos2 + 7) >> 3);
296 enc->pic_->stats->alpha_data_size = (int)enc->alpha_data_size_;
297 }
298#else
299 (void)pos1;
300 (void)pos2;
301 (void)pos3;
302#endif
303 if (bw->error_) {
304 return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
305 }
306 return 1;
307}
308
309void VP8EncFreeBitWriters(VP8Encoder* const enc) {
310 int p;
311 VP8BitWriterWipeOut(&enc->bw_);
312 for (p = 0; p < enc->num_parts_; ++p) {
313 VP8BitWriterWipeOut(enc->parts_ + p);
314 }
315}
316
317int VP8EncWrite(VP8Encoder* const enc) {
318 WebPPicture* const pic = enc->pic_;
319 VP8BitWriter* const bw = &enc->bw_;
320 const int task_percent = 19;
321 const int percent_per_part = task_percent / enc->num_parts_;
322 const int final_percent = enc->percent_ + task_percent;
323 int ok = 0;
324 size_t vp8_size, pad, riff_size;
325 int p;
326
327 // Partition #0 with header and partition sizes
328 ok = GeneratePartition0(enc);
329 if (!ok) return 0;
330
331 // Compute VP8 size
332 vp8_size = VP8_FRAME_HEADER_SIZE +
333 VP8BitWriterSize(bw) +
334 3 * (enc->num_parts_ - 1);
335 for (p = 0; p < enc->num_parts_; ++p) {
336 vp8_size += VP8BitWriterSize(enc->parts_ + p);
337 }
338 pad = vp8_size & 1;
339 vp8_size += pad;
340
341 // Compute RIFF size
342 // At the minimum it is: "WEBPVP8 nnnn" + VP8 data size.
343 riff_size = TAG_SIZE + CHUNK_HEADER_SIZE + vp8_size;
344 if (IsVP8XNeeded(enc)) { // Add size for: VP8X header + data.
345 riff_size += CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
346 }
347 if (enc->has_alpha_) { // Add size for: ALPH header + data.
348 const uint32_t padded_alpha_size = enc->alpha_data_size_ +
349 (enc->alpha_data_size_ & 1);
350 riff_size += CHUNK_HEADER_SIZE + padded_alpha_size;
351 }
352 // Sanity check.
353 if (riff_size > 0xfffffffeU) {
354 return WebPEncodingSetError(pic, VP8_ENC_ERROR_FILE_TOO_BIG);
355 }
356
357 // Emit headers and partition #0
358 {
359 const uint8_t* const part0 = VP8BitWriterBuf(bw);
360 const size_t size0 = VP8BitWriterSize(bw);
361 ok = ok && PutWebPHeaders(enc, size0, vp8_size, riff_size)
362 && pic->writer(part0, size0, pic)
363 && EmitPartitionsSize(enc, pic);
364 VP8BitWriterWipeOut(bw); // will free the internal buffer.
365 }
366
367 // Token partitions
368 for (p = 0; p < enc->num_parts_; ++p) {
369 const uint8_t* const buf = VP8BitWriterBuf(enc->parts_ + p);
370 const size_t size = VP8BitWriterSize(enc->parts_ + p);
371 if (size) ok = ok && pic->writer(buf, size, pic);
372 VP8BitWriterWipeOut(enc->parts_ + p); // will free the internal buffer.
373 ok = ok && WebPReportProgress(pic, enc->percent_ + percent_per_part,
374 &enc->percent_);
375 }
376
377 // Padding byte
378 if (ok && pad) {
379 ok = PutPaddingByte(pic);
380 }
381
382 enc->coded_size_ = (int)(CHUNK_HEADER_SIZE + riff_size);
383 ok = ok && WebPReportProgress(pic, final_percent, &enc->percent_);
384 return ok;
385}
386
387//------------------------------------------------------------------------------
388
389