Lines Matching refs:enc
24 static int IsVP8XNeeded(const VP8Encoder* const enc) {
25 return !!enc->has_alpha_; // Currently the only case when VP8X is needed.
37 static WebPEncodingError PutRIFFHeader(const VP8Encoder* const enc,
39 const WebPPicture* const pic = enc->pic_;
51 static WebPEncodingError PutVP8XHeader(const VP8Encoder* const enc) {
52 const WebPPicture* const pic = enc->pic_;
58 assert(IsVP8XNeeded(enc));
62 if (enc->has_alpha_) {
76 static WebPEncodingError PutAlphaChunk(const VP8Encoder* const enc) {
77 const WebPPicture* const pic = enc->pic_;
82 assert(enc->has_alpha_);
85 PutLE32(alpha_chunk_hdr + TAG_SIZE, enc->alpha_data_size_);
91 if (!pic->writer(enc->alpha_data_, enc->alpha_data_size_, pic)) {
96 if ((enc->alpha_data_size_ & 1) && !PutPaddingByte(pic)) {
149 static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
151 WebPPicture* const pic = enc->pic_;
155 err = PutRIFFHeader(enc, riff_size);
159 if (IsVP8XNeeded(enc)) {
160 err = PutVP8XHeader(enc);
165 if (enc->has_alpha_) {
166 err = PutAlphaChunk(enc);
175 err = PutVP8FrameHeader(pic, enc->profile_, size0);
188 const VP8Encoder* const enc) {
189 const VP8SegmentHeader* const hdr = &enc->segment_hdr_;
190 const VP8Proba* const proba = &enc->proba_;
200 VP8PutSignedValue(bw, enc->dqm_[s].quant_, 7);
203 VP8PutSignedValue(bw, enc->dqm_[s].fstrength_, 6);
238 const VP8Encoder* const enc) {
239 VP8PutValue(bw, enc->base_quant_, 7);
240 VP8PutSignedValue(bw, enc->dq_y1_dc_, 4);
241 VP8PutSignedValue(bw, enc->dq_y2_dc_, 4);
242 VP8PutSignedValue(bw, enc->dq_y2_ac_, 4);
243 VP8PutSignedValue(bw, enc->dq_uv_dc_, 4);
244 VP8PutSignedValue(bw, enc->dq_uv_ac_, 4);
248 static int EmitPartitionsSize(const VP8Encoder* const enc,
252 for (p = 0; p < enc->num_parts_ - 1; ++p) {
253 const size_t part_size = VP8BitWriterSize(enc->parts_ + p);
266 static int GeneratePartition0(VP8Encoder* const enc) {
267 VP8BitWriter* const bw = &enc->bw_;
268 const int mb_size = enc->mb_w_ * enc->mb_h_;
273 return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
278 PutSegmentHeader(bw, enc);
279 PutFilterHeader(bw, &enc->filter_hdr_);
280 VP8PutValue(bw, enc->num_parts_ == 8 ? 3 :
281 enc->num_parts_ == 4 ? 2 :
282 enc->num_parts_ == 2 ? 1 : 0, 2);
283 PutQuant(bw, enc);
285 VP8WriteProbas(bw, &enc->proba_);
287 VP8CodeIntraModes(enc);
292 if (enc->pic_->stats) {
293 enc->pic_->stats->header_bytes[0] = (int)((pos2 - pos1 + 7) >> 3);
294 enc->pic_->stats->header_bytes[1] = (int)((pos3 - pos2 + 7) >> 3);
295 enc->pic_->stats->alpha_data_size = (int)enc->alpha_data_size_;
298 return WebPEncodingSetError(enc->pic_, VP8_ENC_ERROR_OUT_OF_MEMORY);
303 void VP8EncFreeBitWriters(VP8Encoder* const enc) {
305 VP8BitWriterWipeOut(&enc->bw_);
306 for (p = 0; p < enc->num_parts_; ++p) {
307 VP8BitWriterWipeOut(enc->parts_ + p);
311 int VP8EncWrite(VP8Encoder* const enc) {
312 WebPPicture* const pic = enc->pic_;
313 VP8BitWriter* const bw = &enc->bw_;
315 const int percent_per_part = task_percent / enc->num_parts_;
316 const int final_percent = enc->percent_ + task_percent;
322 ok = GeneratePartition0(enc);
328 3 * (enc->num_parts_ - 1);
329 for (p = 0; p < enc->num_parts_; ++p) {
330 vp8_size += VP8BitWriterSize(enc->parts_ + p);
338 if (IsVP8XNeeded(enc)) { // Add size for: VP8X header + data.
341 if (enc->has_alpha_) { // Add size for: ALPH header + data.
342 const uint32_t padded_alpha_size = enc->alpha_data_size_ +
343 (enc->alpha_data_size_ & 1);
355 ok = ok && PutWebPHeaders(enc, size0, vp8_size, riff_size)
357 && EmitPartitionsSize(enc, pic);
362 for (p = 0; p < enc->num_parts_; ++p) {
363 const uint8_t* const buf = VP8BitWriterBuf(enc->parts_ + p);
364 const size_t size = VP8BitWriterSize(enc->parts_ + p);
367 VP8BitWriterWipeOut(enc->parts_ + p); // will free the internal buffer.
368 ok = ok && WebPReportProgress(pic, enc->percent_ + percent_per_part,
369 &enc->percent_);
377 enc->coded_size_ = (int)(CHUNK_HEADER_SIZE + riff_size);
378 ok = ok && WebPReportProgress(pic, final_percent, &enc->percent_);