Lines Matching refs:enc
25 static int IsVP8XNeeded(const VP8Encoder* const enc) {
26 return !!enc->has_alpha_; // Currently the only case when VP8X is needed.
39 static WebPEncodingError PutRIFFHeader(const VP8Encoder* const enc,
41 const WebPPicture* const pic = enc->pic_;
53 static WebPEncodingError PutVP8XHeader(const VP8Encoder* const enc) {
54 const WebPPicture* const pic = enc->pic_;
60 assert(IsVP8XNeeded(enc));
64 if (enc->has_alpha_) {
78 static WebPEncodingError PutAlphaChunk(const VP8Encoder* const enc) {
79 const WebPPicture* const pic = enc->pic_;
84 assert(enc->has_alpha_);
87 PutLE32(alpha_chunk_hdr + TAG_SIZE, enc->alpha_data_size_);
93 if (!pic->writer(enc->alpha_data_, enc->alpha_data_size_, pic)) {
98 if ((enc->alpha_data_size_ & 1) && !PutPaddingByte(pic)) {
151 static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
153 WebPPicture* const pic = enc->pic_;
157 err = PutRIFFHeader(enc, riff_size);
161 if (IsVP8XNeeded(enc)) {
162 err = PutVP8XHeader(enc);
167 if (enc->has_alpha_) {
168 err = PutAlphaChunk(enc);
177 err = PutVP8FrameHeader(pic, enc->profile_, size0);
190 const VP8Encoder* const enc) {
191 const VP8SegmentHeader* const hdr = &enc->segment_hdr_;
192 const VP8Proba* const proba = &enc->proba_;
202 VP8PutSignedValue(bw, enc->dqm_[s].quant_, 7);
205 VP8PutSignedValue(bw, enc->dqm_[s].fstrength_, 6);
240 const VP8Encoder* const enc) {
241 VP8PutValue(bw, enc->base_quant_, 7);
242 VP8PutSignedValue(bw, enc->dq_y1_dc_, 4);
243 VP8PutSignedValue(bw, enc->dq_y2_dc_, 4);
244 VP8PutSignedValue(bw, enc->dq_y2_ac_, 4);
245 VP8PutSignedValue(bw, enc->dq_uv_dc_, 4);
246 VP8PutSignedValue(bw, enc->dq_uv_ac_, 4);
250 static int EmitPartitionsSize(const VP8Encoder* const enc,
254 for (p = 0; p < enc->num_parts_ - 1; ++p) {
255 const size_t part_size = VP8BitWriterSize(enc->parts_ + p);
272 static int WriteExtensions(VP8Encoder* const enc) {
274 VP8BitWriter* const bw = &enc->bw_;
275 WebPPicture* const pic = enc->pic_;
278 PutLE24(buffer + 0, enc->layer_data_size_);
279 buffer[3] = enc->pic_->colorspace & WEBP_CSP_UV_MASK;
280 if (enc->layer_data_size_ > 0) {
281 assert(enc->use_layer_);
283 if (!VP8BitWriterAppend(&enc->parts_[enc->num_parts_ - 1],
284 enc->layer_data_, enc->layer_data_size_)) {
300 static size_t GeneratePartition0(VP8Encoder* const enc) {
301 VP8BitWriter* const bw = &enc->bw_;
302 const int mb_size = enc->mb_w_ * enc->mb_h_;
305 const int need_extensions = enc->use_layer_;
317 PutSegmentHeader(bw, enc);
318 PutFilterHeader(bw, &enc->filter_hdr_);
319 VP8PutValue(bw, enc->num_parts_ == 8 ? 3 :
320 enc->num_parts_ == 4 ? 2 :
321 enc->num_parts_ == 2 ? 1 : 0, 2);
322 PutQuant(bw, enc);
324 VP8WriteProbas(bw, &enc->proba_);
326 VP8CodeIntraModes(enc);
330 if (need_extensions && !WriteExtensions(enc)) {
337 if (enc->pic_->stats) {
338 enc->pic_->stats->header_bytes[0] = (int)((pos2 - pos1 + 7) >> 3);
339 enc->pic_->stats->header_bytes[1] = (int)((pos3 - pos2 + 7) >> 3);
340 enc->pic_->stats->alpha_data_size = (int)enc->alpha_data_size_;
341 enc->pic_->stats->layer_data_size = (int)enc->layer_data_size_;
346 void VP8EncFreeBitWriters(VP8Encoder* const enc) {
348 VP8BitWriterWipeOut(&enc->bw_);
349 for (p = 0; p < enc->num_parts_; ++p) {
350 VP8BitWriterWipeOut(enc->parts_ + p);
354 int VP8EncWrite(VP8Encoder* const enc) {
355 WebPPicture* const pic = enc->pic_;
356 VP8BitWriter* const bw = &enc->bw_;
358 const int percent_per_part = task_percent / enc->num_parts_;
359 const int final_percent = enc->percent_ + task_percent;
365 ok = !!GeneratePartition0(enc);
370 3 * (enc->num_parts_ - 1);
371 for (p = 0; p < enc->num_parts_; ++p) {
372 vp8_size += VP8BitWriterSize(enc->parts_ + p);
380 if (IsVP8XNeeded(enc)) { // Add size for: VP8X header + data.
383 if (enc->has_alpha_) { // Add size for: ALPH header + data.
384 const uint32_t padded_alpha_size = enc->alpha_data_size_ +
385 (enc->alpha_data_size_ & 1);
397 ok = ok && PutWebPHeaders(enc, size0, vp8_size, riff_size)
399 && EmitPartitionsSize(enc, pic);
404 for (p = 0; p < enc->num_parts_; ++p) {
405 const uint8_t* const buf = VP8BitWriterBuf(enc->parts_ + p);
406 const size_t size = VP8BitWriterSize(enc->parts_ + p);
409 VP8BitWriterWipeOut(enc->parts_ + p); // will free the internal buffer.
410 ok = ok && WebPReportProgress(pic, enc->percent_ + percent_per_part,
411 &enc->percent_);
419 enc->coded_size_ = (int)(CHUNK_HEADER_SIZE + riff_size);
420 ok = ok && WebPReportProgress(pic, final_percent, &enc->percent_);
