libwebp/enc/iterator.c

24 static void InitLeft(VP8EncIterator* const it) {
25   const VP8Encoder* const enc = it->enc_;
27       (it->y_) > 0 ? 129 : 127;
31   it->left_nz_[8] = 0;
34 static void InitTop(VP8EncIterator* const it) {
35   const VP8Encoder* const enc = it->enc_;
41 void VP8IteratorReset(VP8EncIterator* const it) {
42   VP8Encoder* const enc = it->enc_;
43   it->x_ = 0;
44   it->y_ = 0;
45   it->y_offset_ = 0;
46   it->uv_offset_ = 0;
47   it->mb_ = enc->mb_info_;
48   it->preds_ = enc->preds_;
49   it->nz_ = enc->nz_;
50   it->bw_ = &enc->parts_[0];
51   it->done_ = enc->mb_w_* enc->mb_h_;
52   InitTop(it);
53   InitLeft(it);
54   memset(it->bit_count_, 0, sizeof(it->bit_count_));
55   it->do_trellis_ = 0;
58 void VP8IteratorInit(VP8Encoder* const enc, VP8EncIterator* const it) {
59   it->enc_ = enc;
60   it->y_stride_  = enc->pic_->y_stride;
61   it->uv_stride_ = enc->pic_->uv_stride;
62   // TODO(later): for multithreading, these should be owned by 'it'.
63   it->yuv_in_   = enc->yuv_in_;
64   it->yuv_out_  = enc->yuv_out_;
65   it->yuv_out2_ = enc->yuv_out2_;
66   it->yuv_p_    = enc->yuv_p_;
67   it->lf_stats_ = enc->lf_stats_;
68   VP8IteratorReset(it);
75 void VP8IteratorImport(const VP8EncIterator* const it) {
76   const VP8Encoder* const enc = it->enc_;
77   const int x = it->x_, y = it->y_;
82   uint8_t* ydst = it->yuv_in_ + Y_OFF;
83   uint8_t* udst = it->yuv_in_ + U_OFF;
84   uint8_t* vdst = it->yuv_in_ + V_OFF;
128 void VP8IteratorExport(const VP8EncIterator* const it) {
129   const VP8Encoder* const enc = it->enc_;
131     const int x = it->x_, y = it->y_;
132     const uint8_t* const ysrc = it->yuv_out_ + Y_OFF;
133     const uint8_t* const usrc = it->yuv_out_ + U_OFF;
134     const uint8_t* const vsrc = it->yuv_out_ + V_OFF;
177 void VP8IteratorNzToBytes(VP8EncIterator* const it) {
178   const int tnz = it->nz_[0], lnz = it->nz_[-1];
181   it->top_nz_[0] = BIT(tnz, 12);
182   it->top_nz_[1] = BIT(tnz, 13);
183   it->top_nz_[2] = BIT(tnz, 14);
184   it->top_nz_[3] = BIT(tnz, 15);
186   it->top_nz_[4] = BIT(tnz, 18);
187   it->top_nz_[5] = BIT(tnz, 19);
189   it->top_nz_[6] = BIT(tnz, 22);
190   it->top_nz_[7] = BIT(tnz, 23);
192   it->top_nz_[8] = BIT(tnz, 24);
195   it->left_nz_[0] = BIT(lnz,  3);
196   it->left_nz_[1] = BIT(lnz,  7);
197   it->left_nz_[2] = BIT(lnz, 11);
198   it->left_nz_[3] = BIT(lnz, 15);
200   it->left_nz_[4] = BIT(lnz, 17);
201   it->left_nz_[5] = BIT(lnz, 19);
203   it->left_nz_[6] = BIT(lnz, 21);
204   it->left_nz_[7] = BIT(lnz, 23);
208 void VP8IteratorBytesToNz(VP8EncIterator* const it) {
211   nz |= (it->top_nz_[0] << 12) | (it->top_nz_[1] << 13);
212   nz |= (it->top_nz_[2] << 14) | (it->top_nz_[3] << 15);
213   nz |= (it->top_nz_[4] << 18) | (it->top_nz_[5] << 19);
214   nz |= (it->top_nz_[6] << 22) | (it->top_nz_[7] << 23);
215   nz |= (it->top_nz_[8] << 24);  // we propagate the _top_ bit, esp. for intra4
217   nz |= (it->left_nz_[0] << 3) | (it->left_nz_[1] << 7) | (it->left_nz_[2] << 11);
218   nz |= (it->left_nz_[4] << 17) | (it->left_nz_[6] << 21);
220   *it->nz_ = nz;
228 int VP8IteratorNext(VP8EncIterator* const it,
230   VP8Encoder* const enc = it->enc_;
232     const int x = it->x_, y = it->y_;
255   it->mb_++;
256   it->preds_ += 4;
257   it->nz_++;
258   it->x_++;
259   if (it->x_ == enc->mb_w_) {
260     it->x_ = 0;
261     it->y_++;
262     it->bw_ = &enc->parts_[it->y_ & (enc->num_parts_ - 1)];
263     it->preds_ = enc->preds_ + it->y_ * 4 * enc->preds_w_;
264     it->nz_ = enc->nz_;
265     InitLeft(it);
267   return (0 < --it->done_);
273 void VP8SetIntra16Mode(const VP8EncIterator* it, int mode) {
275   uint8_t* preds = it->preds_;
278     preds += it->enc_->preds_w_;
280   it->mb_->type_ = 1;
283 void VP8SetIntra4Mode(const VP8EncIterator* const it, int modes[16]) {
285   uint8_t* preds = it->preds_;
290     preds += it->enc_->preds_w_;
292   it->mb_->type_ = 0;
295 void VP8SetIntraUVMode(const VP8EncIterator* const it, int mode) {
296   it->mb_->uv_mode_ = mode;
299 void VP8SetSkip(const VP8EncIterator* const it, int skip) {
300   it->mb_->skip_ = skip;
303 void VP8SetSegment(const VP8EncIterator* const it, int segment) {
304   it->mb_->segment_ = segment;
346 void VP8IteratorStartI4(VP8EncIterator* const it) {
347   VP8Encoder* const enc = it->enc_;
350   it->i4_ = 0;    // first 4x4 sub-block
351   it->i4_top_ = it->i4_boundary_ + VP8TopLeftI4[0];
355     it->i4_boundary_[i] = enc->y_left_[15 - i];
358     it->i4_boundary_[17 + i] = enc->y_top_[it->x_ * 16 + i];
361   if (it->x_ < enc->mb_w_ - 1) {
363       it->i4_boundary_[17 + i] = enc->y_top_[it->x_ * 16 + i];
367       it->i4_boundary_[17 + i] = it->i4_boundary_[17 + 15];
370   VP8IteratorNzToBytes(it);  // import the non-zero context
373 int VP8IteratorRotateI4(VP8EncIterator* const it,
375   const uint8_t* const blk = yuv_out + VP8Scan[it->i4_];
376   uint8_t* const top = it->i4_top_;
383   if ((it->i4_ & 3) != 3) {  // if not on the right sub-blocks #3, #7, #11, #15
393   it->i4_++;
394   if (it->i4_ == 16) {    // we're done
398   it->i4_top_ = it->i4_boundary_ + VP8TopLeftI4[it->i4_];