Lines Matching refs:enc
28 static int IsVP8XNeeded(const VP8Encoder* const enc) {
29 return !!enc->has_alpha_; // Currently the only case when VP8X is needed.
41 static WebPEncodingError PutRIFFHeader(const VP8Encoder* const enc,
43 const WebPPicture* const pic = enc->pic_;
55 static WebPEncodingError PutVP8XHeader(const VP8Encoder* const enc) {
56 const WebPPicture* const pic = enc->pic_;
62 assert(IsVP8XNeeded(enc));
66 if (enc->has_alpha_) {
80 static WebPEncodingError PutAlphaChunk(const VP8Encoder* const enc) {
81 const WebPPicture* const pic = enc->pic_;
86 assert(enc->has_alpha_);
89 PutLE32(alpha_chunk_hdr + TAG_SIZE, enc->alpha_data_size_);
95 if (!pic->writer(enc->alpha_data_, enc->alpha_data_size_, pic)) {
100 if ((enc->alpha_data_size_ & 1) && !PutPaddingByte(pic)) {
153 static int PutWebPHeaders(const VP8Encoder* const enc, size_t size0,
155 WebPPicture* const pic = enc->pic_;
159 err = PutRIFFHeader(enc, riff_size);
163 if (IsVP8XNeeded(enc)) {
164 err = PutVP8XHeader(enc);
169 if (enc->has_alpha_) {
170 err = PutAlphaChunk(enc);
179 err = PutVP8FrameHeader(pic, enc->profile_, size0);
192 const VP8Encoder* const enc) {
193 const VP8SegmentHeader* const hdr = &enc->segment_hdr_;
194 const VP8Proba* const proba = &enc->proba_;
204 VP8PutSignedValue(bw, enc->dqm_[s].quant_, 7);
207 VP8PutSignedValue(bw, enc->dqm_[s].fstrength_, 6);
242 const VP8Encoder* const enc) {
243 VP8PutValue(bw, enc->base_quant_, 7);
244 VP8PutSignedValue(bw, enc->dq_y1_dc_, 4);
245 VP8PutSignedValue(bw, enc->dq_y2_dc_, 4);
246 VP8PutSignedValue(bw, enc->dq_y2_ac_, 4);
247 VP8PutSignedValue(bw, enc->dq_uv_dc_, 4);
248 VP8PutSignedValue(bw, enc->dq_uv_ac_, 4);
252 static int EmitPartitionsSize(const VP8Encoder* const enc,
256 for (p = 0; p < enc->num_parts_ - 1; ++p) {
257 const size_t part_size = VP8BitWriterSize(enc->parts_ + p);
274 static int WriteExtensions(VP8Encoder* const enc) {
276 VP8BitWriter* const bw = &enc->bw_;
277 WebPPicture* const pic = enc->pic_;
280 PutLE24(buffer + 0, enc->layer_data_size_);
281 buffer[3] = enc->pic_->colorspace & WEBP_CSP_UV_MASK;
282 if (enc->layer_data_size_ > 0) {
283 assert(enc->use_layer_);
285 if (!VP8BitWriterAppend(&enc->parts_[enc->num_parts_ - 1],
286 enc->layer_data_, enc->layer_data_size_)) {
302 static size_t GeneratePartition0(VP8Encoder* const enc) {
303 VP8BitWriter* const bw = &enc->bw_;
304 const int mb_size = enc->mb_w_ * enc->mb_h_;
307 const int need_extensions = enc->use_layer_;
319 PutSegmentHeader(bw, enc);
320 PutFilterHeader(bw, &enc->filter_hdr_);
321 VP8PutValue(bw, enc->num_parts_ == 8 ? 3 :
322 enc->num_parts_ == 4 ? 2 :
323 enc->num_parts_ == 2 ? 1 : 0, 2);
324 PutQuant(bw, enc);
326 VP8WriteProbas(bw, &enc->proba_);
328 VP8CodeIntraModes(enc);
332 if (need_extensions && !WriteExtensions(enc)) {
339 if (enc->pic_->stats) {
340 enc->pic_->stats->header_bytes[0] = (int)((pos2 - pos1 + 7) >> 3);
341 enc->pic_->stats->header_bytes[1] = (int)((pos3 - pos2 + 7) >> 3);
342 enc->pic_->stats->alpha_data_size = (int)enc->alpha_data_size_;
343 enc->pic_->stats->layer_data_size = (int)enc->layer_data_size_;
348 void VP8EncFreeBitWriters(VP8Encoder* const enc) {
350 VP8BitWriterWipeOut(&enc->bw_);
351 for (p = 0; p < enc->num_parts_; ++p) {
352 VP8BitWriterWipeOut(enc->parts_ + p);
356 int VP8EncWrite(VP8Encoder* const enc) {
357 WebPPicture* const pic = enc->pic_;
358 VP8BitWriter* const bw = &enc->bw_;
360 const int percent_per_part = task_percent / enc->num_parts_;
361 const int final_percent = enc->percent_ + task_percent;
367 ok = !!GeneratePartition0(enc);
372 3 * (enc->num_parts_ - 1);
373 for (p = 0; p < enc->num_parts_; ++p) {
374 vp8_size += VP8BitWriterSize(enc->parts_ + p);
382 if (IsVP8XNeeded(enc)) { // Add size for: VP8X header + data.
385 if (enc->has_alpha_) { // Add size for: ALPH header + data.
386 const uint32_t padded_alpha_size = enc->alpha_data_size_ +
387 (enc->alpha_data_size_ & 1);
399 ok = ok && PutWebPHeaders(enc, size0, vp8_size, riff_size)
401 && EmitPartitionsSize(enc, pic);
406 for (p = 0; p < enc->num_parts_; ++p) {
407 const uint8_t* const buf = VP8BitWriterBuf(enc->parts_ + p);
408 const size_t size = VP8BitWriterSize(enc->parts_ + p);
411 VP8BitWriterWipeOut(enc->parts_ + p); // will free the internal buffer.
412 ok = ok && WebPReportProgress(pic, enc->percent_ + percent_per_part,
413 &enc->percent_);
421 enc->coded_size_ = (int)(CHUNK_HEADER_SIZE + riff_size);
422 ok = ok && WebPReportProgress(pic, final_percent, &enc->percent_);
