xref: /aosp_15_r20/external/libgav1/src/tile/bitstream/mode_info.cc (revision 095378508e87ed692bf8dfeb34008b65b3735891)
1 // Copyright 2019 The libgav1 Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //      http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include <algorithm>
16 #include <array>
17 #include <cassert>
18 #include <cstdint>
19 #include <cstdlib>
20 #include <cstring>
21 #include <memory>
22 #include <vector>
23 
24 #include "src/buffer_pool.h"
25 #include "src/dsp/constants.h"
26 #include "src/motion_vector.h"
27 #include "src/obu_parser.h"
28 #include "src/prediction_mask.h"
29 #include "src/symbol_decoder_context.h"
30 #include "src/tile.h"
31 #include "src/utils/array_2d.h"
32 #include "src/utils/bit_mask_set.h"
33 #include "src/utils/block_parameters_holder.h"
34 #include "src/utils/common.h"
35 #include "src/utils/constants.h"
36 #include "src/utils/entropy_decoder.h"
37 #include "src/utils/logging.h"
38 #include "src/utils/segmentation.h"
39 #include "src/utils/segmentation_map.h"
40 #include "src/utils/types.h"
41 
42 namespace libgav1 {
43 namespace {
44 
45 constexpr int kDeltaQSmall = 3;
46 constexpr int kDeltaLfSmall = 3;
47 
48 constexpr uint8_t kIntraYModeContext[kIntraPredictionModesY] = {
49     0, 1, 2, 3, 4, 4, 4, 4, 3, 0, 1, 2, 0};
50 
51 constexpr uint8_t kSizeGroup[kMaxBlockSizes] = {
52     0, 0, 0, 0, 1, 1, 1, 0, 1, 2, 2, 2, 1, 2, 3, 3, 2, 3, 3, 3, 3, 3};
53 
54 constexpr int kCompoundModeNewMvContexts = 5;
55 constexpr uint8_t kCompoundModeContextMap[3][kCompoundModeNewMvContexts] = {
56     {0, 1, 1, 1, 1}, {1, 2, 3, 4, 4}, {4, 4, 5, 6, 7}};
57 
58 enum CflSign : uint8_t {
59   kCflSignZero = 0,
60   kCflSignNegative = 1,
61   kCflSignPositive = 2
62 };
63 
64 // For each possible value of the combined signs (which is read from the
65 // bitstream), this array stores the following: sign_u, sign_v, alpha_u_context,
66 // alpha_v_context. Only positive entries are used. Entry at index i is computed
67 // as follows:
68 // sign_u = i / 3
69 // sign_v = i % 3
70 // alpha_u_context = i - 2
71 // alpha_v_context = (sign_v - 1) * 3 + sign_u
72 constexpr int8_t kCflAlphaLookup[kCflAlphaSignsSymbolCount][4] = {
73     {0, 1, -2, 0}, {0, 2, -1, 3}, {1, 0, 0, -2}, {1, 1, 1, 1},
74     {1, 2, 2, 4},  {2, 0, 3, -1}, {2, 1, 4, 2},  {2, 2, 5, 5},
75 };
76 
77 constexpr BitMaskSet kPredictionModeHasNearMvMask(kPredictionModeNearMv,
78                                                   kPredictionModeNearNearMv,
79                                                   kPredictionModeNearNewMv,
80                                                   kPredictionModeNewNearMv);
81 
82 constexpr BitMaskSet kIsInterIntraModeAllowedMask(kBlock8x8, kBlock8x16,
83                                                   kBlock16x8, kBlock16x16,
84                                                   kBlock16x32, kBlock32x16,
85                                                   kBlock32x32);
86 
IsBackwardReference(ReferenceFrameType type)87 bool IsBackwardReference(ReferenceFrameType type) {
88   return type >= kReferenceFrameBackward && type <= kReferenceFrameAlternate;
89 }
90 
IsSameDirectionReferencePair(ReferenceFrameType type1,ReferenceFrameType type2)91 bool IsSameDirectionReferencePair(ReferenceFrameType type1,
92                                   ReferenceFrameType type2) {
93   return (type1 >= kReferenceFrameBackward) ==
94          (type2 >= kReferenceFrameBackward);
95 }
96 
97 // This is called neg_deinterleave() in the spec.
DecodeSegmentId(int diff,int reference,int max)98 int DecodeSegmentId(int diff, int reference, int max) {
99   if (reference == 0) return diff;
100   if (reference >= max - 1) return max - diff - 1;
101   const int value = ((diff & 1) != 0) ? reference + ((diff + 1) >> 1)
102                                       : reference - (diff >> 1);
103   const int reference2 = (reference << 1);
104   if (reference2 < max) {
105     return (diff <= reference2) ? value : diff;
106   }
107   return (diff <= ((max - reference - 1) << 1)) ? value : max - (diff + 1);
108 }
109 
110 // This is called DrlCtxStack in section 7.10.2.14 of the spec.
111 // In the spec, the weights of all the nearest mvs are incremented by a bonus
112 // weight which is larger than any natural weight, and the weights of the mvs
113 // are compared with this bonus weight to determine their contexts. We replace
114 // this procedure by introducing |nearest_mv_count| in PredictionParameters,
115 // which records the count of the nearest mvs. Since all the nearest mvs are in
116 // the beginning of the mv stack, the |index| of a mv in the mv stack can be
117 // compared with |nearest_mv_count| to get that mv's context.
GetRefMvIndexContext(int nearest_mv_count,int index)118 int GetRefMvIndexContext(int nearest_mv_count, int index) {
119   if (index + 1 < nearest_mv_count) {
120     return 0;
121   }
122   if (index + 1 == nearest_mv_count) {
123     return 1;
124   }
125   return 2;
126 }
127 
128 // Returns true if both the width and height of the block is less than 64.
IsBlockDimensionLessThan64(BlockSize size)129 bool IsBlockDimensionLessThan64(BlockSize size) {
130   return size <= kBlock32x32 && size != kBlock16x64;
131 }
132 
GetUseCompoundReferenceContext(const Tile::Block & block)133 int GetUseCompoundReferenceContext(const Tile::Block& block) {
134   if (block.top_available[kPlaneY] && block.left_available[kPlaneY]) {
135     if (block.IsTopSingle() && block.IsLeftSingle()) {
136       return static_cast<int>(IsBackwardReference(block.TopReference(0))) ^
137              static_cast<int>(IsBackwardReference(block.LeftReference(0)));
138     }
139     if (block.IsTopSingle()) {
140       return 2 + static_cast<int>(IsBackwardReference(block.TopReference(0)) ||
141                                   block.IsTopIntra());
142     }
143     if (block.IsLeftSingle()) {
144       return 2 + static_cast<int>(IsBackwardReference(block.LeftReference(0)) ||
145                                   block.IsLeftIntra());
146     }
147     return 4;
148   }
149   if (block.top_available[kPlaneY]) {
150     return block.IsTopSingle()
151                ? static_cast<int>(IsBackwardReference(block.TopReference(0)))
152                : 3;
153   }
154   if (block.left_available[kPlaneY]) {
155     return block.IsLeftSingle()
156                ? static_cast<int>(IsBackwardReference(block.LeftReference(0)))
157                : 3;
158   }
159   return 1;
160 }
161 
162 // Calculates count0 by calling block.CountReferences() on the frame types from
163 // type0_start to type0_end, inclusive, and summing the results.
164 // Calculates count1 by calling block.CountReferences() on the frame types from
165 // type1_start to type1_end, inclusive, and summing the results.
166 // Compares count0 with count1 and returns 0, 1 or 2.
167 //
168 // See count_refs and ref_count_ctx in 8.3.2.
GetReferenceContext(const Tile::Block & block,ReferenceFrameType type0_start,ReferenceFrameType type0_end,ReferenceFrameType type1_start,ReferenceFrameType type1_end)169 int GetReferenceContext(const Tile::Block& block,
170                         ReferenceFrameType type0_start,
171                         ReferenceFrameType type0_end,
172                         ReferenceFrameType type1_start,
173                         ReferenceFrameType type1_end) {
174   int count0 = 0;
175   int count1 = 0;
176   for (int type = type0_start; type <= type0_end; ++type) {
177     count0 += block.CountReferences(static_cast<ReferenceFrameType>(type));
178   }
179   for (int type = type1_start; type <= type1_end; ++type) {
180     count1 += block.CountReferences(static_cast<ReferenceFrameType>(type));
181   }
182   return (count0 < count1) ? 0 : (count0 == count1 ? 1 : 2);
183 }
184 
185 }  // namespace
186 
ReadSegmentId(const Block & block)187 bool Tile::ReadSegmentId(const Block& block) {
188   // These two asserts ensure that current_frame_.segmentation_map() is not
189   // nullptr.
190   assert(frame_header_.segmentation.enabled);
191   assert(frame_header_.segmentation.update_map);
192   const SegmentationMap& map = *current_frame_.segmentation_map();
193   int top_left = -1;
194   if (block.top_available[kPlaneY] && block.left_available[kPlaneY]) {
195     top_left = map.segment_id(block.row4x4 - 1, block.column4x4 - 1);
196   }
197   int top = -1;
198   if (block.top_available[kPlaneY]) {
199     top = map.segment_id(block.row4x4 - 1, block.column4x4);
200   }
201   int left = -1;
202   if (block.left_available[kPlaneY]) {
203     left = map.segment_id(block.row4x4, block.column4x4 - 1);
204   }
205   int pred;
206   if (top == -1) {
207     pred = (left == -1) ? 0 : left;
208   } else if (left == -1) {
209     pred = top;
210   } else {
211     pred = (top_left == top) ? top : left;
212   }
213   BlockParameters& bp = *block.bp;
214   if (bp.skip) {
215     bp.prediction_parameters->segment_id = pred;
216     return true;
217   }
218   int context = 0;
219   if (top_left < 0) {
220     context = 0;
221   } else if (top_left == top && top_left == left) {
222     context = 2;
223   } else if (top_left == top || top_left == left || top == left) {
224     context = 1;
225   }
226   uint16_t* const segment_id_cdf =
227       symbol_decoder_context_.segment_id_cdf[context];
228   const int encoded_segment_id =
229       reader_.ReadSymbol<kMaxSegments>(segment_id_cdf);
230   bp.prediction_parameters->segment_id =
231       DecodeSegmentId(encoded_segment_id, pred,
232                       frame_header_.segmentation.last_active_segment_id + 1);
233   // Check the bitstream conformance requirement in Section 6.10.8 of the spec.
234   if (bp.prediction_parameters->segment_id < 0 ||
235       bp.prediction_parameters->segment_id >
236           frame_header_.segmentation.last_active_segment_id) {
237     LIBGAV1_DLOG(
238         ERROR,
239         "Corrupted segment_ids: encoded %d, last active %d, postprocessed %d",
240         encoded_segment_id, frame_header_.segmentation.last_active_segment_id,
241         bp.prediction_parameters->segment_id);
242     return false;
243   }
244   return true;
245 }
246 
ReadIntraSegmentId(const Block & block)247 bool Tile::ReadIntraSegmentId(const Block& block) {
248   BlockParameters& bp = *block.bp;
249   if (!frame_header_.segmentation.enabled) {
250     bp.prediction_parameters->segment_id = 0;
251     return true;
252   }
253   return ReadSegmentId(block);
254 }
255 
ReadSkip(const Block & block)256 void Tile::ReadSkip(const Block& block) {
257   BlockParameters& bp = *block.bp;
258   if (frame_header_.segmentation.segment_id_pre_skip &&
259       frame_header_.segmentation.FeatureActive(
260           bp.prediction_parameters->segment_id, kSegmentFeatureSkip)) {
261     bp.skip = true;
262     return;
263   }
264   int context = 0;
265   if (block.top_available[kPlaneY] && block.bp_top->skip) {
266     ++context;
267   }
268   if (block.left_available[kPlaneY] && block.bp_left->skip) {
269     ++context;
270   }
271   uint16_t* const skip_cdf = symbol_decoder_context_.skip_cdf[context];
272   bp.skip = reader_.ReadSymbol(skip_cdf);
273 }
274 
ReadSkipMode(const Block & block)275 bool Tile::ReadSkipMode(const Block& block) {
276   BlockParameters& bp = *block.bp;
277   if (!frame_header_.skip_mode_present ||
278       frame_header_.segmentation.FeatureActive(
279           bp.prediction_parameters->segment_id, kSegmentFeatureSkip) ||
280       frame_header_.segmentation.FeatureActive(
281           bp.prediction_parameters->segment_id,
282           kSegmentFeatureReferenceFrame) ||
283       frame_header_.segmentation.FeatureActive(
284           bp.prediction_parameters->segment_id, kSegmentFeatureGlobalMv) ||
285       IsBlockDimension4(block.size)) {
286     return false;
287   }
288   const int context =
289       (block.left_available[kPlaneY]
290            ? static_cast<int>(left_context_.skip_mode[block.left_context_index])
291            : 0) +
292       (block.top_available[kPlaneY]
293            ? static_cast<int>(
294                  block.top_context->skip_mode[block.top_context_index])
295            : 0);
296   return reader_.ReadSymbol(symbol_decoder_context_.skip_mode_cdf[context]);
297 }
298 
ReadCdef(const Block & block)299 void Tile::ReadCdef(const Block& block) {
300   BlockParameters& bp = *block.bp;
301   if (bp.skip || frame_header_.coded_lossless ||
302       !sequence_header_.enable_cdef || frame_header_.allow_intrabc ||
303       frame_header_.cdef.bits == 0) {
304     return;
305   }
306   int8_t* const cdef_index =
307       &cdef_index_[DivideBy16(block.row4x4)][DivideBy16(block.column4x4)];
308   int stride = cdef_index_.columns();
309   if (cdef_index[0] == -1) {
310     cdef_index[0] =
311         static_cast<int8_t>(reader_.ReadLiteral(frame_header_.cdef.bits));
312     if (block.size == kBlock128x128) {
313       // This condition is shorthand for block.width4x4 > 16 && block.height4x4
314       // > 16.
315       cdef_index[1] = cdef_index[0];
316       cdef_index[stride] = cdef_index[0];
317       cdef_index[stride + 1] = cdef_index[0];
318     } else if (block.width4x4 > 16) {
319       cdef_index[1] = cdef_index[0];
320     } else if (block.height4x4 > 16) {
321       cdef_index[stride] = cdef_index[0];
322     }
323   }
324 }
325 
ReadAndClipDelta(uint16_t * const cdf,int delta_small,int scale,int min_value,int max_value,int value)326 int Tile::ReadAndClipDelta(uint16_t* const cdf, int delta_small, int scale,
327                            int min_value, int max_value, int value) {
328   int abs = reader_.ReadSymbol<kDeltaSymbolCount>(cdf);
329   if (abs == delta_small) {
330     const int remaining_bit_count =
331         static_cast<int>(reader_.ReadLiteral(3)) + 1;
332     const int abs_remaining_bits =
333         static_cast<int>(reader_.ReadLiteral(remaining_bit_count));
334     abs = abs_remaining_bits + (1 << remaining_bit_count) + 1;
335   }
336   if (abs != 0) {
337     const bool sign = reader_.ReadBit() != 0;
338     const int scaled_abs = abs << scale;
339     const int reduced_delta = sign ? -scaled_abs : scaled_abs;
340     value += reduced_delta;
341     value = Clip3(value, min_value, max_value);
342   }
343   return value;
344 }
345 
ReadQuantizerIndexDelta(const Block & block)346 void Tile::ReadQuantizerIndexDelta(const Block& block) {
347   assert(read_deltas_);
348   BlockParameters& bp = *block.bp;
349   if ((block.size == SuperBlockSize() && bp.skip)) {
350     return;
351   }
352   current_quantizer_index_ =
353       ReadAndClipDelta(symbol_decoder_context_.delta_q_cdf, kDeltaQSmall,
354                        frame_header_.delta_q.scale, kMinLossyQuantizer,
355                        kMaxQuantizer, current_quantizer_index_);
356 }
357 
ReadLoopFilterDelta(const Block & block)358 void Tile::ReadLoopFilterDelta(const Block& block) {
359   assert(read_deltas_);
360   BlockParameters& bp = *block.bp;
361   if (!frame_header_.delta_lf.present ||
362       (block.size == SuperBlockSize() && bp.skip)) {
363     return;
364   }
365   int frame_lf_count = 1;
366   if (frame_header_.delta_lf.multi) {
367     frame_lf_count = kFrameLfCount - (PlaneCount() > 1 ? 0 : 2);
368   }
369   bool recompute_deblock_filter_levels = false;
370   for (int i = 0; i < frame_lf_count; ++i) {
371     uint16_t* const delta_lf_abs_cdf =
372         frame_header_.delta_lf.multi
373             ? symbol_decoder_context_.delta_lf_multi_cdf[i]
374             : symbol_decoder_context_.delta_lf_cdf;
375     const int8_t old_delta_lf = delta_lf_[i];
376     delta_lf_[i] = ReadAndClipDelta(
377         delta_lf_abs_cdf, kDeltaLfSmall, frame_header_.delta_lf.scale,
378         -kMaxLoopFilterValue, kMaxLoopFilterValue, delta_lf_[i]);
379     recompute_deblock_filter_levels =
380         recompute_deblock_filter_levels || (old_delta_lf != delta_lf_[i]);
381   }
382   delta_lf_all_zero_ =
383       (delta_lf_[0] | delta_lf_[1] | delta_lf_[2] | delta_lf_[3]) == 0;
384   if (!delta_lf_all_zero_ && recompute_deblock_filter_levels) {
385     post_filter_.ComputeDeblockFilterLevels(delta_lf_, deblock_filter_levels_);
386   }
387 }
388 
ReadPredictionModeY(const Block & block,bool intra_y_mode)389 void Tile::ReadPredictionModeY(const Block& block, bool intra_y_mode) {
390   uint16_t* cdf;
391   if (intra_y_mode) {
392     const PredictionMode top_mode =
393         block.top_available[kPlaneY] ? block.bp_top->y_mode : kPredictionModeDc;
394     const PredictionMode left_mode = block.left_available[kPlaneY]
395                                          ? block.bp_left->y_mode
396                                          : kPredictionModeDc;
397     const int top_context = kIntraYModeContext[top_mode];
398     const int left_context = kIntraYModeContext[left_mode];
399     cdf = symbol_decoder_context_
400               .intra_frame_y_mode_cdf[top_context][left_context];
401   } else {
402     cdf = symbol_decoder_context_.y_mode_cdf[kSizeGroup[block.size]];
403   }
404   block.bp->y_mode = static_cast<PredictionMode>(
405       reader_.ReadSymbol<kIntraPredictionModesY>(cdf));
406 }
407 
ReadIntraAngleInfo(const Block & block,PlaneType plane_type)408 void Tile::ReadIntraAngleInfo(const Block& block, PlaneType plane_type) {
409   BlockParameters& bp = *block.bp;
410   PredictionParameters& prediction_parameters =
411       *block.bp->prediction_parameters;
412   prediction_parameters.angle_delta[plane_type] = 0;
413   const PredictionMode mode = (plane_type == kPlaneTypeY)
414                                   ? bp.y_mode
415                                   : bp.prediction_parameters->uv_mode;
416   if (IsBlockSmallerThan8x8(block.size) || !IsDirectionalMode(mode)) return;
417   uint16_t* const cdf =
418       symbol_decoder_context_.angle_delta_cdf[mode - kPredictionModeVertical];
419   prediction_parameters.angle_delta[plane_type] =
420       reader_.ReadSymbol<kAngleDeltaSymbolCount>(cdf);
421   prediction_parameters.angle_delta[plane_type] -= kMaxAngleDelta;
422 }
423 
ReadCflAlpha(const Block & block)424 void Tile::ReadCflAlpha(const Block& block) {
425   const int signs = reader_.ReadSymbol<kCflAlphaSignsSymbolCount>(
426       symbol_decoder_context_.cfl_alpha_signs_cdf);
427   const int8_t* const cfl_lookup = kCflAlphaLookup[signs];
428   const auto sign_u = static_cast<CflSign>(cfl_lookup[0]);
429   const auto sign_v = static_cast<CflSign>(cfl_lookup[1]);
430   PredictionParameters& prediction_parameters =
431       *block.bp->prediction_parameters;
432   prediction_parameters.cfl_alpha_u = 0;
433   if (sign_u != kCflSignZero) {
434     assert(cfl_lookup[2] >= 0);
435     prediction_parameters.cfl_alpha_u =
436         reader_.ReadSymbol<kCflAlphaSymbolCount>(
437             symbol_decoder_context_.cfl_alpha_cdf[cfl_lookup[2]]) +
438         1;
439     if (sign_u == kCflSignNegative) prediction_parameters.cfl_alpha_u *= -1;
440   }
441   prediction_parameters.cfl_alpha_v = 0;
442   if (sign_v != kCflSignZero) {
443     assert(cfl_lookup[3] >= 0);
444     prediction_parameters.cfl_alpha_v =
445         reader_.ReadSymbol<kCflAlphaSymbolCount>(
446             symbol_decoder_context_.cfl_alpha_cdf[cfl_lookup[3]]) +
447         1;
448     if (sign_v == kCflSignNegative) prediction_parameters.cfl_alpha_v *= -1;
449   }
450 }
451 
ReadPredictionModeUV(const Block & block)452 void Tile::ReadPredictionModeUV(const Block& block) {
453   BlockParameters& bp = *block.bp;
454   bool chroma_from_luma_allowed;
455   if (frame_header_.segmentation
456           .lossless[bp.prediction_parameters->segment_id]) {
457     chroma_from_luma_allowed = block.residual_size[kPlaneU] == kBlock4x4;
458   } else {
459     chroma_from_luma_allowed = IsBlockDimensionLessThan64(block.size);
460   }
461   uint16_t* const cdf =
462       symbol_decoder_context_
463           .uv_mode_cdf[static_cast<int>(chroma_from_luma_allowed)][bp.y_mode];
464   if (chroma_from_luma_allowed) {
465     bp.prediction_parameters->uv_mode = static_cast<PredictionMode>(
466         reader_.ReadSymbol<kIntraPredictionModesUV>(cdf));
467   } else {
468     bp.prediction_parameters->uv_mode = static_cast<PredictionMode>(
469         reader_.ReadSymbol<kIntraPredictionModesUV - 1>(cdf));
470   }
471 }
472 
ReadMotionVectorComponent(const Block & block,const int component)473 int Tile::ReadMotionVectorComponent(const Block& block, const int component) {
474   const int context =
475       static_cast<int>(block.bp->prediction_parameters->use_intra_block_copy);
476   const bool sign = reader_.ReadSymbol(
477       symbol_decoder_context_.mv_sign_cdf[component][context]);
478   const int mv_class = reader_.ReadSymbol<kMvClassSymbolCount>(
479       symbol_decoder_context_.mv_class_cdf[component][context]);
480   int magnitude = 1;
481   int value;
482   uint16_t* fraction_cdf;
483   uint16_t* precision_cdf;
484   if (mv_class == 0) {
485     value = static_cast<int>(reader_.ReadSymbol(
486         symbol_decoder_context_.mv_class0_bit_cdf[component][context]));
487     fraction_cdf = symbol_decoder_context_
488                        .mv_class0_fraction_cdf[component][context][value];
489     precision_cdf = symbol_decoder_context_
490                         .mv_class0_high_precision_cdf[component][context];
491   } else {
492     assert(mv_class <= kMvBitSymbolCount);
493     value = 0;
494     for (int i = 0; i < mv_class; ++i) {
495       const int bit = static_cast<int>(reader_.ReadSymbol(
496           symbol_decoder_context_.mv_bit_cdf[component][context][i]));
497       value |= bit << i;
498     }
499     magnitude += 2 << (mv_class + 2);
500     fraction_cdf = symbol_decoder_context_.mv_fraction_cdf[component][context];
501     precision_cdf =
502         symbol_decoder_context_.mv_high_precision_cdf[component][context];
503   }
504   const int fraction =
505       (frame_header_.force_integer_mv == 0)
506           ? reader_.ReadSymbol<kMvFractionSymbolCount>(fraction_cdf)
507           : 3;
508   const int precision =
509       frame_header_.allow_high_precision_mv
510           ? static_cast<int>(reader_.ReadSymbol(precision_cdf))
511           : 1;
512   magnitude += (value << 3) | (fraction << 1) | precision;
513   return sign ? -magnitude : magnitude;
514 }
515 
ReadMotionVector(const Block & block,int index)516 void Tile::ReadMotionVector(const Block& block, int index) {
517   BlockParameters& bp = *block.bp;
518   const int context =
519       static_cast<int>(block.bp->prediction_parameters->use_intra_block_copy);
520   const auto mv_joint =
521       static_cast<MvJointType>(reader_.ReadSymbol<kNumMvJointTypes>(
522           symbol_decoder_context_.mv_joint_cdf[context]));
523   if (mv_joint == kMvJointTypeHorizontalZeroVerticalNonZero ||
524       mv_joint == kMvJointTypeNonZero) {
525     bp.mv.mv[index].mv[0] = ReadMotionVectorComponent(block, 0);
526   }
527   if (mv_joint == kMvJointTypeHorizontalNonZeroVerticalZero ||
528       mv_joint == kMvJointTypeNonZero) {
529     bp.mv.mv[index].mv[1] = ReadMotionVectorComponent(block, 1);
530   }
531 }
532 
ReadFilterIntraModeInfo(const Block & block)533 void Tile::ReadFilterIntraModeInfo(const Block& block) {
534   BlockParameters& bp = *block.bp;
535   PredictionParameters& prediction_parameters =
536       *block.bp->prediction_parameters;
537   prediction_parameters.use_filter_intra = false;
538   if (!sequence_header_.enable_filter_intra || bp.y_mode != kPredictionModeDc ||
539       bp.prediction_parameters->palette_mode_info.size[kPlaneTypeY] != 0 ||
540       !IsBlockDimensionLessThan64(block.size)) {
541     return;
542   }
543   prediction_parameters.use_filter_intra = reader_.ReadSymbol(
544       symbol_decoder_context_.use_filter_intra_cdf[block.size]);
545   if (prediction_parameters.use_filter_intra) {
546     prediction_parameters.filter_intra_mode = static_cast<FilterIntraPredictor>(
547         reader_.ReadSymbol<kNumFilterIntraPredictors>(
548             symbol_decoder_context_.filter_intra_mode_cdf));
549   }
550 }
551 
DecodeIntraModeInfo(const Block & block)552 bool Tile::DecodeIntraModeInfo(const Block& block) {
553   BlockParameters& bp = *block.bp;
554   bp.skip = false;
555   if (frame_header_.segmentation.segment_id_pre_skip &&
556       !ReadIntraSegmentId(block)) {
557     return false;
558   }
559   SetCdfContextSkipMode(block, false);
560   ReadSkip(block);
561   if (!frame_header_.segmentation.segment_id_pre_skip &&
562       !ReadIntraSegmentId(block)) {
563     return false;
564   }
565   ReadCdef(block);
566   if (read_deltas_) {
567     ReadQuantizerIndexDelta(block);
568     ReadLoopFilterDelta(block);
569     read_deltas_ = false;
570   }
571   PredictionParameters& prediction_parameters =
572       *block.bp->prediction_parameters;
573   prediction_parameters.use_intra_block_copy = false;
574   if (frame_header_.allow_intrabc) {
575     prediction_parameters.use_intra_block_copy =
576         reader_.ReadSymbol(symbol_decoder_context_.intra_block_copy_cdf);
577   }
578   if (prediction_parameters.use_intra_block_copy) {
579     bp.is_inter = true;
580     bp.reference_frame[0] = kReferenceFrameIntra;
581     bp.reference_frame[1] = kReferenceFrameNone;
582     bp.y_mode = kPredictionModeDc;
583     bp.prediction_parameters->uv_mode = kPredictionModeDc;
584     SetCdfContextUVMode(block);
585     prediction_parameters.motion_mode = kMotionModeSimple;
586     prediction_parameters.compound_prediction_type =
587         kCompoundPredictionTypeAverage;
588     bp.prediction_parameters->palette_mode_info.size[kPlaneTypeY] = 0;
589     bp.prediction_parameters->palette_mode_info.size[kPlaneTypeUV] = 0;
590     SetCdfContextPaletteSize(block);
591     bp.interpolation_filter[0] = kInterpolationFilterBilinear;
592     bp.interpolation_filter[1] = kInterpolationFilterBilinear;
593     MvContexts dummy_mode_contexts;
594     FindMvStack(block, /*is_compound=*/false, &dummy_mode_contexts);
595     return AssignIntraMv(block);
596   }
597   bp.is_inter = false;
598   return ReadIntraBlockModeInfo(block, /*intra_y_mode=*/true);
599 }
600 
ComputePredictedSegmentId(const Block & block) const601 int8_t Tile::ComputePredictedSegmentId(const Block& block) const {
602   // If prev_segment_ids_ is null, treat it as if it pointed to a segmentation
603   // map containing all 0s.
604   if (prev_segment_ids_ == nullptr) return 0;
605 
606   const int x_limit = std::min(frame_header_.columns4x4 - block.column4x4,
607                                static_cast<int>(block.width4x4));
608   const int y_limit = std::min(frame_header_.rows4x4 - block.row4x4,
609                                static_cast<int>(block.height4x4));
610   int8_t id = 7;
611   for (int y = 0; y < y_limit; ++y) {
612     for (int x = 0; x < x_limit; ++x) {
613       const int8_t prev_segment_id =
614           prev_segment_ids_->segment_id(block.row4x4 + y, block.column4x4 + x);
615       id = std::min(id, prev_segment_id);
616     }
617   }
618   return id;
619 }
620 
SetCdfContextUsePredictedSegmentId(const Block & block,bool use_predicted_segment_id)621 void Tile::SetCdfContextUsePredictedSegmentId(const Block& block,
622                                               bool use_predicted_segment_id) {
623   memset(left_context_.use_predicted_segment_id + block.left_context_index,
624          static_cast<int>(use_predicted_segment_id), block.height4x4);
625   memset(block.top_context->use_predicted_segment_id + block.top_context_index,
626          static_cast<int>(use_predicted_segment_id), block.width4x4);
627 }
628 
ReadInterSegmentId(const Block & block,bool pre_skip)629 bool Tile::ReadInterSegmentId(const Block& block, bool pre_skip) {
630   BlockParameters& bp = *block.bp;
631   if (!frame_header_.segmentation.enabled) {
632     bp.prediction_parameters->segment_id = 0;
633     return true;
634   }
635   if (!frame_header_.segmentation.update_map) {
636     bp.prediction_parameters->segment_id = ComputePredictedSegmentId(block);
637     return true;
638   }
639   if (pre_skip) {
640     if (!frame_header_.segmentation.segment_id_pre_skip) {
641       bp.prediction_parameters->segment_id = 0;
642       return true;
643     }
644   } else if (bp.skip) {
645     SetCdfContextUsePredictedSegmentId(block, false);
646     return ReadSegmentId(block);
647   }
648   if (frame_header_.segmentation.temporal_update) {
649     const int context =
650         (block.left_available[kPlaneY]
651              ? static_cast<int>(
652                    left_context_
653                        .use_predicted_segment_id[block.left_context_index])
654              : 0) +
655         (block.top_available[kPlaneY]
656              ? static_cast<int>(
657                    block.top_context
658                        ->use_predicted_segment_id[block.top_context_index])
659              : 0);
660     const bool use_predicted_segment_id = reader_.ReadSymbol(
661         symbol_decoder_context_.use_predicted_segment_id_cdf[context]);
662     SetCdfContextUsePredictedSegmentId(block, use_predicted_segment_id);
663     if (use_predicted_segment_id) {
664       bp.prediction_parameters->segment_id = ComputePredictedSegmentId(block);
665       return true;
666     }
667   }
668   return ReadSegmentId(block);
669 }
670 
ReadIsInter(const Block & block,bool skip_mode)671 void Tile::ReadIsInter(const Block& block, bool skip_mode) {
672   BlockParameters& bp = *block.bp;
673   if (skip_mode) {
674     bp.is_inter = true;
675     return;
676   }
677   if (frame_header_.segmentation.FeatureActive(
678           bp.prediction_parameters->segment_id,
679           kSegmentFeatureReferenceFrame)) {
680     bp.is_inter = frame_header_.segmentation
681                       .feature_data[bp.prediction_parameters->segment_id]
682                                    [kSegmentFeatureReferenceFrame] !=
683                   kReferenceFrameIntra;
684     return;
685   }
686   if (frame_header_.segmentation.FeatureActive(
687           bp.prediction_parameters->segment_id, kSegmentFeatureGlobalMv)) {
688     bp.is_inter = true;
689     return;
690   }
691   int context = 0;
692   if (block.top_available[kPlaneY] && block.left_available[kPlaneY]) {
693     context = (block.IsTopIntra() && block.IsLeftIntra())
694                   ? 3
695                   : static_cast<int>(block.IsTopIntra() || block.IsLeftIntra());
696   } else if (block.top_available[kPlaneY] || block.left_available[kPlaneY]) {
697     context = 2 * static_cast<int>(block.top_available[kPlaneY]
698                                        ? block.IsTopIntra()
699                                        : block.IsLeftIntra());
700   }
701   bp.is_inter =
702       reader_.ReadSymbol(symbol_decoder_context_.is_inter_cdf[context]);
703 }
704 
SetCdfContextPaletteSize(const Block & block)705 void Tile::SetCdfContextPaletteSize(const Block& block) {
706   const PaletteModeInfo& palette_mode_info =
707       block.bp->prediction_parameters->palette_mode_info;
708   for (int plane_type = kPlaneTypeY; plane_type <= kPlaneTypeUV; ++plane_type) {
709     memset(left_context_.palette_size[plane_type] + block.left_context_index,
710            palette_mode_info.size[plane_type], block.height4x4);
711     memset(
712         block.top_context->palette_size[plane_type] + block.top_context_index,
713         palette_mode_info.size[plane_type], block.width4x4);
714     if (palette_mode_info.size[plane_type] == 0) continue;
715     for (int i = block.left_context_index;
716          i < block.left_context_index + block.height4x4; ++i) {
717       memcpy(left_context_.palette_color[i][plane_type],
718              palette_mode_info.color[plane_type],
719              kMaxPaletteSize * sizeof(palette_mode_info.color[0][0]));
720     }
721     for (int i = block.top_context_index;
722          i < block.top_context_index + block.width4x4; ++i) {
723       memcpy(block.top_context->palette_color[i][plane_type],
724              palette_mode_info.color[plane_type],
725              kMaxPaletteSize * sizeof(palette_mode_info.color[0][0]));
726     }
727   }
728 }
729 
SetCdfContextUVMode(const Block & block)730 void Tile::SetCdfContextUVMode(const Block& block) {
731   // BlockCdfContext.uv_mode is only used to compute is_smooth_prediction for
732   // the intra edge upsamplers in the subsequent blocks. They have some special
733   // rules for subsampled UV planes. For subsampled UV planes, update left
734   // context only if current block contains the last odd column and update top
735   // context only if current block contains the last odd row.
736   if (subsampling_x_[kPlaneU] == 0 || (block.column4x4 & 1) == 1 ||
737       block.width4x4 > 1) {
738     memset(left_context_.uv_mode + block.left_context_index,
739            block.bp->prediction_parameters->uv_mode, block.height4x4);
740   }
741   if (subsampling_y_[kPlaneU] == 0 || (block.row4x4 & 1) == 1 ||
742       block.height4x4 > 1) {
743     memset(block.top_context->uv_mode + block.top_context_index,
744            block.bp->prediction_parameters->uv_mode, block.width4x4);
745   }
746 }
747 
ReadIntraBlockModeInfo(const Block & block,bool intra_y_mode)748 bool Tile::ReadIntraBlockModeInfo(const Block& block, bool intra_y_mode) {
749   BlockParameters& bp = *block.bp;
750   bp.reference_frame[0] = kReferenceFrameIntra;
751   bp.reference_frame[1] = kReferenceFrameNone;
752   ReadPredictionModeY(block, intra_y_mode);
753   ReadIntraAngleInfo(block, kPlaneTypeY);
754   if (block.HasChroma()) {
755     ReadPredictionModeUV(block);
756     if (bp.prediction_parameters->uv_mode == kPredictionModeChromaFromLuma) {
757       ReadCflAlpha(block);
758     }
759     if (block.left_available[kPlaneU]) {
760       const int smooth_row =
761           block.row4x4 + (~block.row4x4 & subsampling_y_[kPlaneU]);
762       const int smooth_column =
763           block.column4x4 - 1 - (block.column4x4 & subsampling_x_[kPlaneU]);
764       const BlockParameters& bp_left =
765           *block_parameters_holder_.Find(smooth_row, smooth_column);
766       bp.prediction_parameters->chroma_left_uses_smooth_prediction =
767           (bp_left.reference_frame[0] <= kReferenceFrameIntra) &&
768           kPredictionModeSmoothMask.Contains(
769               left_context_.uv_mode[CdfContextIndex(smooth_row)]);
770     }
771     if (block.top_available[kPlaneU]) {
772       const int smooth_row =
773           block.row4x4 - 1 - (block.row4x4 & subsampling_y_[kPlaneU]);
774       const int smooth_column =
775           block.column4x4 + (~block.column4x4 & subsampling_x_[kPlaneU]);
776       const BlockParameters& bp_top =
777           *block_parameters_holder_.Find(smooth_row, smooth_column);
778       bp.prediction_parameters->chroma_top_uses_smooth_prediction =
779           (bp_top.reference_frame[0] <= kReferenceFrameIntra) &&
780           kPredictionModeSmoothMask.Contains(
781               top_context_.get()[SuperBlockColumnIndex(smooth_column)]
782                   .uv_mode[CdfContextIndex(smooth_column)]);
783     }
784     SetCdfContextUVMode(block);
785     ReadIntraAngleInfo(block, kPlaneTypeUV);
786   }
787   ReadPaletteModeInfo(block);
788   SetCdfContextPaletteSize(block);
789   ReadFilterIntraModeInfo(block);
790   return true;
791 }
792 
ReadCompoundReferenceType(const Block & block)793 CompoundReferenceType Tile::ReadCompoundReferenceType(const Block& block) {
794   // compound and inter.
795   const bool top_comp_inter = block.top_available[kPlaneY] &&
796                               !block.IsTopIntra() && !block.IsTopSingle();
797   const bool left_comp_inter = block.left_available[kPlaneY] &&
798                                !block.IsLeftIntra() && !block.IsLeftSingle();
799   // unidirectional compound.
800   const bool top_uni_comp =
801       top_comp_inter && IsSameDirectionReferencePair(block.TopReference(0),
802                                                      block.TopReference(1));
803   const bool left_uni_comp =
804       left_comp_inter && IsSameDirectionReferencePair(block.LeftReference(0),
805                                                       block.LeftReference(1));
806   int context;
807   if (block.top_available[kPlaneY] && !block.IsTopIntra() &&
808       block.left_available[kPlaneY] && !block.IsLeftIntra()) {
809     const int same_direction = static_cast<int>(IsSameDirectionReferencePair(
810         block.TopReference(0), block.LeftReference(0)));
811     if (!top_comp_inter && !left_comp_inter) {
812       context = 1 + MultiplyBy2(same_direction);
813     } else if (!top_comp_inter) {
814       context = left_uni_comp ? 3 + same_direction : 1;
815     } else if (!left_comp_inter) {
816       context = top_uni_comp ? 3 + same_direction : 1;
817     } else {
818       if (!top_uni_comp && !left_uni_comp) {
819         context = 0;
820       } else if (!top_uni_comp || !left_uni_comp) {
821         context = 2;
822       } else {
823         context = 3 + static_cast<int>(
824                           (block.TopReference(0) == kReferenceFrameBackward) ==
825                           (block.LeftReference(0) == kReferenceFrameBackward));
826       }
827     }
828   } else if (block.top_available[kPlaneY] && block.left_available[kPlaneY]) {
829     if (top_comp_inter) {
830       context = 1 + MultiplyBy2(static_cast<int>(top_uni_comp));
831     } else if (left_comp_inter) {
832       context = 1 + MultiplyBy2(static_cast<int>(left_uni_comp));
833     } else {
834       context = 2;
835     }
836   } else if (top_comp_inter) {
837     context = MultiplyBy4(static_cast<int>(top_uni_comp));
838   } else if (left_comp_inter) {
839     context = MultiplyBy4(static_cast<int>(left_uni_comp));
840   } else {
841     context = 2;
842   }
843   return static_cast<CompoundReferenceType>(reader_.ReadSymbol(
844       symbol_decoder_context_.compound_reference_type_cdf[context]));
845 }
846 
847 template <bool is_single, bool is_backward, int index>
GetReferenceCdf(const Block & block,CompoundReferenceType type)848 uint16_t* Tile::GetReferenceCdf(
849     const Block& block,
850     CompoundReferenceType type /*= kNumCompoundReferenceTypes*/) {
851   int context = 0;
852   if ((type == kCompoundReferenceUnidirectional && index == 0) ||
853       (is_single && index == 1)) {
854     // uni_comp_ref and single_ref_p1.
855     context =
856         GetReferenceContext(block, kReferenceFrameLast, kReferenceFrameGolden,
857                             kReferenceFrameBackward, kReferenceFrameAlternate);
858   } else if (type == kCompoundReferenceUnidirectional && index == 1) {
859     // uni_comp_ref_p1.
860     context =
861         GetReferenceContext(block, kReferenceFrameLast2, kReferenceFrameLast2,
862                             kReferenceFrameLast3, kReferenceFrameGolden);
863   } else if ((type == kCompoundReferenceUnidirectional && index == 2) ||
864              (type == kCompoundReferenceBidirectional && index == 2) ||
865              (is_single && index == 5)) {
866     // uni_comp_ref_p2, comp_ref_p2 and single_ref_p5.
867     context =
868         GetReferenceContext(block, kReferenceFrameLast3, kReferenceFrameLast3,
869                             kReferenceFrameGolden, kReferenceFrameGolden);
870   } else if ((type == kCompoundReferenceBidirectional && index == 0) ||
871              (is_single && index == 3)) {
872     // comp_ref and single_ref_p3.
873     context =
874         GetReferenceContext(block, kReferenceFrameLast, kReferenceFrameLast2,
875                             kReferenceFrameLast3, kReferenceFrameGolden);
876   } else if ((type == kCompoundReferenceBidirectional && index == 1) ||
877              (is_single && index == 4)) {
878     // comp_ref_p1 and single_ref_p4.
879     context =
880         GetReferenceContext(block, kReferenceFrameLast, kReferenceFrameLast,
881                             kReferenceFrameLast2, kReferenceFrameLast2);
882   } else if ((is_single && index == 2) || (is_backward && index == 0)) {
883     // single_ref_p2 and comp_bwdref.
884     context = GetReferenceContext(
885         block, kReferenceFrameBackward, kReferenceFrameAlternate2,
886         kReferenceFrameAlternate, kReferenceFrameAlternate);
887   } else if ((is_single && index == 6) || (is_backward && index == 1)) {
888     // single_ref_p6 and comp_bwdref_p1.
889     context = GetReferenceContext(
890         block, kReferenceFrameBackward, kReferenceFrameBackward,
891         kReferenceFrameAlternate2, kReferenceFrameAlternate2);
892   }
893   // When using GCC 12.x for some targets the compiler reports a false positive
894   // with the context subscript when is_single=false, is_backward=false and
895   // index=0. GetReferenceContext() can only return values between 0 and 2.
896 #ifdef __GNUC__
897 #pragma GCC diagnostic push
898 #pragma GCC diagnostic ignored "-Warray-bounds"
899 #endif
900   assert(context >= 0 && context <= 2);
901   if (is_single) {
902     // The index parameter for single references is offset by one since the spec
903     // uses 1-based index for these elements.
904     return symbol_decoder_context_.single_reference_cdf[context][index - 1];
905   }
906   if (is_backward) {
907     return symbol_decoder_context_
908         .compound_backward_reference_cdf[context][index];
909   }
910   return symbol_decoder_context_.compound_reference_cdf[type][context][index];
911 #ifdef __GNUC__
912 #pragma GCC diagnostic pop
913 #endif
914 }
915 
ReadReferenceFrames(const Block & block,bool skip_mode)916 void Tile::ReadReferenceFrames(const Block& block, bool skip_mode) {
917   BlockParameters& bp = *block.bp;
918   if (skip_mode) {
919     bp.reference_frame[0] = frame_header_.skip_mode_frame[0];
920     bp.reference_frame[1] = frame_header_.skip_mode_frame[1];
921     return;
922   }
923   if (frame_header_.segmentation.FeatureActive(
924           bp.prediction_parameters->segment_id,
925           kSegmentFeatureReferenceFrame)) {
926     bp.reference_frame[0] = static_cast<ReferenceFrameType>(
927         frame_header_.segmentation
928             .feature_data[bp.prediction_parameters->segment_id]
929                          [kSegmentFeatureReferenceFrame]);
930     bp.reference_frame[1] = kReferenceFrameNone;
931     return;
932   }
933   if (frame_header_.segmentation.FeatureActive(
934           bp.prediction_parameters->segment_id, kSegmentFeatureSkip) ||
935       frame_header_.segmentation.FeatureActive(
936           bp.prediction_parameters->segment_id, kSegmentFeatureGlobalMv)) {
937     bp.reference_frame[0] = kReferenceFrameLast;
938     bp.reference_frame[1] = kReferenceFrameNone;
939     return;
940   }
941   const bool use_compound_reference =
942       frame_header_.reference_mode_select &&
943       std::min(block.width4x4, block.height4x4) >= 2 &&
944       reader_.ReadSymbol(symbol_decoder_context_.use_compound_reference_cdf
945                              [GetUseCompoundReferenceContext(block)]);
946   if (use_compound_reference) {
947     CompoundReferenceType reference_type = ReadCompoundReferenceType(block);
948     if (reference_type == kCompoundReferenceUnidirectional) {
949       // uni_comp_ref.
950       if (reader_.ReadSymbol(
951               GetReferenceCdf<false, false, 0>(block, reference_type))) {
952         bp.reference_frame[0] = kReferenceFrameBackward;
953         bp.reference_frame[1] = kReferenceFrameAlternate;
954         return;
955       }
956       // uni_comp_ref_p1.
957       if (!reader_.ReadSymbol(
958               GetReferenceCdf<false, false, 1>(block, reference_type))) {
959         bp.reference_frame[0] = kReferenceFrameLast;
960         bp.reference_frame[1] = kReferenceFrameLast2;
961         return;
962       }
963       // uni_comp_ref_p2.
964       if (reader_.ReadSymbol(
965               GetReferenceCdf<false, false, 2>(block, reference_type))) {
966         bp.reference_frame[0] = kReferenceFrameLast;
967         bp.reference_frame[1] = kReferenceFrameGolden;
968         return;
969       }
970       bp.reference_frame[0] = kReferenceFrameLast;
971       bp.reference_frame[1] = kReferenceFrameLast3;
972       return;
973     }
974     assert(reference_type == kCompoundReferenceBidirectional);
975     // comp_ref.
976     if (reader_.ReadSymbol(
977             GetReferenceCdf<false, false, 0>(block, reference_type))) {
978       // comp_ref_p2.
979       bp.reference_frame[0] =
980           reader_.ReadSymbol(
981               GetReferenceCdf<false, false, 2>(block, reference_type))
982               ? kReferenceFrameGolden
983               : kReferenceFrameLast3;
984     } else {
985       // comp_ref_p1.
986       bp.reference_frame[0] =
987           reader_.ReadSymbol(
988               GetReferenceCdf<false, false, 1>(block, reference_type))
989               ? kReferenceFrameLast2
990               : kReferenceFrameLast;
991     }
992     // comp_bwdref.
993     if (reader_.ReadSymbol(GetReferenceCdf<false, true, 0>(block))) {
994       bp.reference_frame[1] = kReferenceFrameAlternate;
995     } else {
996       // comp_bwdref_p1.
997       bp.reference_frame[1] =
998           reader_.ReadSymbol(GetReferenceCdf<false, true, 1>(block))
999               ? kReferenceFrameAlternate2
1000               : kReferenceFrameBackward;
1001     }
1002     return;
1003   }
1004   assert(!use_compound_reference);
1005   bp.reference_frame[1] = kReferenceFrameNone;
1006   // single_ref_p1.
1007   if (reader_.ReadSymbol(GetReferenceCdf<true, false, 1>(block))) {
1008     // single_ref_p2.
1009     if (reader_.ReadSymbol(GetReferenceCdf<true, false, 2>(block))) {
1010       bp.reference_frame[0] = kReferenceFrameAlternate;
1011       return;
1012     }
1013     // single_ref_p6.
1014     bp.reference_frame[0] =
1015         reader_.ReadSymbol(GetReferenceCdf<true, false, 6>(block))
1016             ? kReferenceFrameAlternate2
1017             : kReferenceFrameBackward;
1018     return;
1019   }
1020   // single_ref_p3.
1021   if (reader_.ReadSymbol(GetReferenceCdf<true, false, 3>(block))) {
1022     // single_ref_p5.
1023     bp.reference_frame[0] =
1024         reader_.ReadSymbol(GetReferenceCdf<true, false, 5>(block))
1025             ? kReferenceFrameGolden
1026             : kReferenceFrameLast3;
1027     return;
1028   }
1029   // single_ref_p4.
1030   bp.reference_frame[0] =
1031       reader_.ReadSymbol(GetReferenceCdf<true, false, 4>(block))
1032           ? kReferenceFrameLast2
1033           : kReferenceFrameLast;
1034 }
1035 
ReadInterPredictionModeY(const Block & block,const MvContexts & mode_contexts,bool skip_mode)1036 void Tile::ReadInterPredictionModeY(const Block& block,
1037                                     const MvContexts& mode_contexts,
1038                                     bool skip_mode) {
1039   BlockParameters& bp = *block.bp;
1040   if (skip_mode) {
1041     bp.y_mode = kPredictionModeNearestNearestMv;
1042     return;
1043   }
1044   if (frame_header_.segmentation.FeatureActive(
1045           bp.prediction_parameters->segment_id, kSegmentFeatureSkip) ||
1046       frame_header_.segmentation.FeatureActive(
1047           bp.prediction_parameters->segment_id, kSegmentFeatureGlobalMv)) {
1048     bp.y_mode = kPredictionModeGlobalMv;
1049     return;
1050   }
1051   if (bp.reference_frame[1] > kReferenceFrameIntra) {
1052     const int idx0 = mode_contexts.reference_mv >> 1;
1053     const int idx1 =
1054         std::min(mode_contexts.new_mv, kCompoundModeNewMvContexts - 1);
1055     const int context = kCompoundModeContextMap[idx0][idx1];
1056     const int offset = reader_.ReadSymbol<kNumCompoundInterPredictionModes>(
1057         symbol_decoder_context_.compound_prediction_mode_cdf[context]);
1058     bp.y_mode =
1059         static_cast<PredictionMode>(kPredictionModeNearestNearestMv + offset);
1060     return;
1061   }
1062   // new_mv.
1063   if (!reader_.ReadSymbol(
1064           symbol_decoder_context_.new_mv_cdf[mode_contexts.new_mv])) {
1065     bp.y_mode = kPredictionModeNewMv;
1066     return;
1067   }
1068   // zero_mv.
1069   if (!reader_.ReadSymbol(
1070           symbol_decoder_context_.zero_mv_cdf[mode_contexts.zero_mv])) {
1071     bp.y_mode = kPredictionModeGlobalMv;
1072     return;
1073   }
1074   // ref_mv.
1075   bp.y_mode =
1076       reader_.ReadSymbol(
1077           symbol_decoder_context_.reference_mv_cdf[mode_contexts.reference_mv])
1078           ? kPredictionModeNearMv
1079           : kPredictionModeNearestMv;
1080 }
1081 
ReadRefMvIndex(const Block & block)1082 void Tile::ReadRefMvIndex(const Block& block) {
1083   BlockParameters& bp = *block.bp;
1084   PredictionParameters& prediction_parameters =
1085       *block.bp->prediction_parameters;
1086   prediction_parameters.ref_mv_index = 0;
1087   if (bp.y_mode != kPredictionModeNewMv &&
1088       bp.y_mode != kPredictionModeNewNewMv &&
1089       !kPredictionModeHasNearMvMask.Contains(bp.y_mode)) {
1090     return;
1091   }
1092   const int start =
1093       static_cast<int>(kPredictionModeHasNearMvMask.Contains(bp.y_mode));
1094   prediction_parameters.ref_mv_index = start;
1095   for (int i = start; i < start + 2; ++i) {
1096     if (prediction_parameters.ref_mv_count <= i + 1) break;
1097     // drl_mode in the spec.
1098     const bool ref_mv_index_bit = reader_.ReadSymbol(
1099         symbol_decoder_context_.ref_mv_index_cdf[GetRefMvIndexContext(
1100             prediction_parameters.nearest_mv_count, i)]);
1101     prediction_parameters.ref_mv_index = i + static_cast<int>(ref_mv_index_bit);
1102     if (!ref_mv_index_bit) return;
1103   }
1104 }
1105 
ReadInterIntraMode(const Block & block,bool is_compound,bool skip_mode)1106 void Tile::ReadInterIntraMode(const Block& block, bool is_compound,
1107                               bool skip_mode) {
1108   BlockParameters& bp = *block.bp;
1109   PredictionParameters& prediction_parameters =
1110       *block.bp->prediction_parameters;
1111   prediction_parameters.inter_intra_mode = kNumInterIntraModes;
1112   prediction_parameters.is_wedge_inter_intra = false;
1113   if (skip_mode || !sequence_header_.enable_interintra_compound ||
1114       is_compound || !kIsInterIntraModeAllowedMask.Contains(block.size)) {
1115     return;
1116   }
1117   // kSizeGroup[block.size] is guaranteed to be non-zero because of the block
1118   // size constraint enforced in the above condition.
1119   assert(kSizeGroup[block.size] - 1 >= 0);
1120   if (!reader_.ReadSymbol(
1121           symbol_decoder_context_
1122               .is_inter_intra_cdf[kSizeGroup[block.size] - 1])) {
1123     prediction_parameters.inter_intra_mode = kNumInterIntraModes;
1124     return;
1125   }
1126   prediction_parameters.inter_intra_mode =
1127       static_cast<InterIntraMode>(reader_.ReadSymbol<kNumInterIntraModes>(
1128           symbol_decoder_context_
1129               .inter_intra_mode_cdf[kSizeGroup[block.size] - 1]));
1130   bp.reference_frame[1] = kReferenceFrameIntra;
1131   prediction_parameters.angle_delta[kPlaneTypeY] = 0;
1132   prediction_parameters.angle_delta[kPlaneTypeUV] = 0;
1133   prediction_parameters.use_filter_intra = false;
1134   prediction_parameters.is_wedge_inter_intra = reader_.ReadSymbol(
1135       symbol_decoder_context_.is_wedge_inter_intra_cdf[block.size]);
1136   if (!prediction_parameters.is_wedge_inter_intra) return;
1137   prediction_parameters.wedge_index =
1138       reader_.ReadSymbol<kWedgeIndexSymbolCount>(
1139           symbol_decoder_context_.wedge_index_cdf[block.size]);
1140   prediction_parameters.wedge_sign = 0;
1141 }
1142 
ReadMotionMode(const Block & block,bool is_compound,bool skip_mode)1143 void Tile::ReadMotionMode(const Block& block, bool is_compound,
1144                           bool skip_mode) {
1145   BlockParameters& bp = *block.bp;
1146   PredictionParameters& prediction_parameters =
1147       *block.bp->prediction_parameters;
1148   const auto global_motion_type =
1149       frame_header_.global_motion[bp.reference_frame[0]].type;
1150   if (skip_mode || !frame_header_.is_motion_mode_switchable ||
1151       IsBlockDimension4(block.size) ||
1152       (frame_header_.force_integer_mv == 0 &&
1153        (bp.y_mode == kPredictionModeGlobalMv ||
1154         bp.y_mode == kPredictionModeGlobalGlobalMv) &&
1155        global_motion_type > kGlobalMotionTransformationTypeTranslation) ||
1156       is_compound || bp.reference_frame[1] == kReferenceFrameIntra ||
1157       !block.HasOverlappableCandidates()) {
1158     prediction_parameters.motion_mode = kMotionModeSimple;
1159     return;
1160   }
1161   prediction_parameters.num_warp_samples = 0;
1162   int num_samples_scanned = 0;
1163   memset(prediction_parameters.warp_estimate_candidates, 0,
1164          sizeof(prediction_parameters.warp_estimate_candidates));
1165   FindWarpSamples(block, &prediction_parameters.num_warp_samples,
1166                   &num_samples_scanned,
1167                   prediction_parameters.warp_estimate_candidates);
1168   if (frame_header_.force_integer_mv != 0 ||
1169       prediction_parameters.num_warp_samples == 0 ||
1170       !frame_header_.allow_warped_motion || IsScaled(bp.reference_frame[0])) {
1171     prediction_parameters.motion_mode =
1172         reader_.ReadSymbol(symbol_decoder_context_.use_obmc_cdf[block.size])
1173             ? kMotionModeObmc
1174             : kMotionModeSimple;
1175     return;
1176   }
1177   prediction_parameters.motion_mode =
1178       static_cast<MotionMode>(reader_.ReadSymbol<kNumMotionModes>(
1179           symbol_decoder_context_.motion_mode_cdf[block.size]));
1180 }
1181 
GetIsExplicitCompoundTypeCdf(const Block & block)1182 uint16_t* Tile::GetIsExplicitCompoundTypeCdf(const Block& block) {
1183   int context = 0;
1184   if (block.top_available[kPlaneY]) {
1185     if (!block.IsTopSingle()) {
1186       context += static_cast<int>(
1187           block.top_context
1188               ->is_explicit_compound_type[block.top_context_index]);
1189     } else if (block.TopReference(0) == kReferenceFrameAlternate) {
1190       context += 3;
1191     }
1192   }
1193   if (block.left_available[kPlaneY]) {
1194     if (!block.IsLeftSingle()) {
1195       context += static_cast<int>(
1196           left_context_.is_explicit_compound_type[block.left_context_index]);
1197     } else if (block.LeftReference(0) == kReferenceFrameAlternate) {
1198       context += 3;
1199     }
1200   }
1201   return symbol_decoder_context_.is_explicit_compound_type_cdf[std::min(
1202       context, kIsExplicitCompoundTypeContexts - 1)];
1203 }
1204 
GetIsCompoundTypeAverageCdf(const Block & block)1205 uint16_t* Tile::GetIsCompoundTypeAverageCdf(const Block& block) {
1206   const BlockParameters& bp = *block.bp;
1207   const ReferenceInfo& reference_info = *current_frame_.reference_info();
1208   const int forward =
1209       std::abs(reference_info.relative_distance_from[bp.reference_frame[0]]);
1210   const int backward =
1211       std::abs(reference_info.relative_distance_from[bp.reference_frame[1]]);
1212   int context = (forward == backward) ? 3 : 0;
1213   if (block.top_available[kPlaneY]) {
1214     if (!block.IsTopSingle()) {
1215       context += static_cast<int>(
1216           block.top_context->is_compound_type_average[block.top_context_index]);
1217     } else if (block.TopReference(0) == kReferenceFrameAlternate) {
1218       ++context;
1219     }
1220   }
1221   if (block.left_available[kPlaneY]) {
1222     if (!block.IsLeftSingle()) {
1223       context += static_cast<int>(
1224           left_context_.is_compound_type_average[block.left_context_index]);
1225     } else if (block.LeftReference(0) == kReferenceFrameAlternate) {
1226       ++context;
1227     }
1228   }
1229   return symbol_decoder_context_.is_compound_type_average_cdf[context];
1230 }
1231 
ReadCompoundType(const Block & block,bool is_compound,bool skip_mode,bool * const is_explicit_compound_type,bool * const is_compound_type_average)1232 void Tile::ReadCompoundType(const Block& block, bool is_compound,
1233                             bool skip_mode,
1234                             bool* const is_explicit_compound_type,
1235                             bool* const is_compound_type_average) {
1236   *is_explicit_compound_type = false;
1237   *is_compound_type_average = true;
1238   PredictionParameters& prediction_parameters =
1239       *block.bp->prediction_parameters;
1240   if (skip_mode) {
1241     prediction_parameters.compound_prediction_type =
1242         kCompoundPredictionTypeAverage;
1243     return;
1244   }
1245   if (is_compound) {
1246     if (sequence_header_.enable_masked_compound) {
1247       *is_explicit_compound_type =
1248           reader_.ReadSymbol(GetIsExplicitCompoundTypeCdf(block));
1249     }
1250     if (*is_explicit_compound_type) {
1251       if (kIsWedgeCompoundModeAllowed.Contains(block.size)) {
1252         // Only kCompoundPredictionTypeWedge and
1253         // kCompoundPredictionTypeDiffWeighted are signaled explicitly.
1254         prediction_parameters.compound_prediction_type =
1255             static_cast<CompoundPredictionType>(reader_.ReadSymbol(
1256                 symbol_decoder_context_.compound_type_cdf[block.size]));
1257       } else {
1258         prediction_parameters.compound_prediction_type =
1259             kCompoundPredictionTypeDiffWeighted;
1260       }
1261     } else {
1262       if (sequence_header_.enable_jnt_comp) {
1263         *is_compound_type_average =
1264             reader_.ReadSymbol(GetIsCompoundTypeAverageCdf(block));
1265         prediction_parameters.compound_prediction_type =
1266             *is_compound_type_average ? kCompoundPredictionTypeAverage
1267                                       : kCompoundPredictionTypeDistance;
1268       } else {
1269         prediction_parameters.compound_prediction_type =
1270             kCompoundPredictionTypeAverage;
1271         return;
1272       }
1273     }
1274     if (prediction_parameters.compound_prediction_type ==
1275         kCompoundPredictionTypeWedge) {
1276       prediction_parameters.wedge_index =
1277           reader_.ReadSymbol<kWedgeIndexSymbolCount>(
1278               symbol_decoder_context_.wedge_index_cdf[block.size]);
1279       prediction_parameters.wedge_sign = static_cast<int>(reader_.ReadBit());
1280     } else if (prediction_parameters.compound_prediction_type ==
1281                kCompoundPredictionTypeDiffWeighted) {
1282       prediction_parameters.mask_is_inverse = reader_.ReadBit() != 0;
1283     }
1284     return;
1285   }
1286   if (prediction_parameters.inter_intra_mode != kNumInterIntraModes) {
1287     prediction_parameters.compound_prediction_type =
1288         prediction_parameters.is_wedge_inter_intra
1289             ? kCompoundPredictionTypeWedge
1290             : kCompoundPredictionTypeIntra;
1291     return;
1292   }
1293   prediction_parameters.compound_prediction_type =
1294       kCompoundPredictionTypeAverage;
1295 }
1296 
GetInterpolationFilterCdf(const Block & block,int direction)1297 uint16_t* Tile::GetInterpolationFilterCdf(const Block& block, int direction) {
1298   const BlockParameters& bp = *block.bp;
1299   int context = MultiplyBy8(direction) +
1300                 MultiplyBy4(static_cast<int>(bp.reference_frame[1] >
1301                                              kReferenceFrameIntra));
1302   int top_type = kNumExplicitInterpolationFilters;
1303   if (block.top_available[kPlaneY]) {
1304     if (block.bp_top->reference_frame[0] == bp.reference_frame[0] ||
1305         block.bp_top->reference_frame[1] == bp.reference_frame[0]) {
1306       top_type = block.bp_top->interpolation_filter[direction];
1307     }
1308   }
1309   int left_type = kNumExplicitInterpolationFilters;
1310   if (block.left_available[kPlaneY]) {
1311     if (block.bp_left->reference_frame[0] == bp.reference_frame[0] ||
1312         block.bp_left->reference_frame[1] == bp.reference_frame[0]) {
1313       left_type = block.bp_left->interpolation_filter[direction];
1314     }
1315   }
1316   if (left_type == top_type) {
1317     context += left_type;
1318   } else if (left_type == kNumExplicitInterpolationFilters) {
1319     context += top_type;
1320   } else if (top_type == kNumExplicitInterpolationFilters) {
1321     context += left_type;
1322   } else {
1323     context += kNumExplicitInterpolationFilters;
1324   }
1325   return symbol_decoder_context_.interpolation_filter_cdf[context];
1326 }
1327 
ReadInterpolationFilter(const Block & block,bool skip_mode)1328 void Tile::ReadInterpolationFilter(const Block& block, bool skip_mode) {
1329   BlockParameters& bp = *block.bp;
1330   if (frame_header_.interpolation_filter != kInterpolationFilterSwitchable) {
1331     static_assert(
1332         sizeof(bp.interpolation_filter) / sizeof(bp.interpolation_filter[0]) ==
1333             2,
1334         "Interpolation filter array size is not 2");
1335     for (auto& interpolation_filter : bp.interpolation_filter) {
1336       interpolation_filter = frame_header_.interpolation_filter;
1337     }
1338     return;
1339   }
1340   bool interpolation_filter_present = true;
1341   if (skip_mode ||
1342       block.bp->prediction_parameters->motion_mode == kMotionModeLocalWarp) {
1343     interpolation_filter_present = false;
1344   } else if (!IsBlockDimension4(block.size) &&
1345              bp.y_mode == kPredictionModeGlobalMv) {
1346     interpolation_filter_present =
1347         frame_header_.global_motion[bp.reference_frame[0]].type ==
1348         kGlobalMotionTransformationTypeTranslation;
1349   } else if (!IsBlockDimension4(block.size) &&
1350              bp.y_mode == kPredictionModeGlobalGlobalMv) {
1351     interpolation_filter_present =
1352         frame_header_.global_motion[bp.reference_frame[0]].type ==
1353             kGlobalMotionTransformationTypeTranslation ||
1354         frame_header_.global_motion[bp.reference_frame[1]].type ==
1355             kGlobalMotionTransformationTypeTranslation;
1356   }
1357   for (int i = 0; i < (sequence_header_.enable_dual_filter ? 2 : 1); ++i) {
1358     bp.interpolation_filter[i] =
1359         interpolation_filter_present
1360             ? static_cast<InterpolationFilter>(
1361                   reader_.ReadSymbol<kNumExplicitInterpolationFilters>(
1362                       GetInterpolationFilterCdf(block, i)))
1363             : kInterpolationFilterEightTap;
1364   }
1365   if (!sequence_header_.enable_dual_filter) {
1366     bp.interpolation_filter[1] = bp.interpolation_filter[0];
1367   }
1368 }
1369 
SetCdfContextCompoundType(const Block & block,bool is_explicit_compound_type,bool is_compound_type_average)1370 void Tile::SetCdfContextCompoundType(const Block& block,
1371                                      bool is_explicit_compound_type,
1372                                      bool is_compound_type_average) {
1373   memset(left_context_.is_explicit_compound_type + block.left_context_index,
1374          static_cast<int>(is_explicit_compound_type), block.height4x4);
1375   memset(left_context_.is_compound_type_average + block.left_context_index,
1376          static_cast<int>(is_compound_type_average), block.height4x4);
1377   memset(block.top_context->is_explicit_compound_type + block.top_context_index,
1378          static_cast<int>(is_explicit_compound_type), block.width4x4);
1379   memset(block.top_context->is_compound_type_average + block.top_context_index,
1380          static_cast<int>(is_compound_type_average), block.width4x4);
1381 }
1382 
ReadInterBlockModeInfo(const Block & block,bool skip_mode)1383 bool Tile::ReadInterBlockModeInfo(const Block& block, bool skip_mode) {
1384   BlockParameters& bp = *block.bp;
1385   bp.prediction_parameters->palette_mode_info.size[kPlaneTypeY] = 0;
1386   bp.prediction_parameters->palette_mode_info.size[kPlaneTypeUV] = 0;
1387   SetCdfContextPaletteSize(block);
1388   ReadReferenceFrames(block, skip_mode);
1389   const bool is_compound = bp.reference_frame[1] > kReferenceFrameIntra;
1390   MvContexts mode_contexts;
1391   FindMvStack(block, is_compound, &mode_contexts);
1392   ReadInterPredictionModeY(block, mode_contexts, skip_mode);
1393   ReadRefMvIndex(block);
1394   if (!AssignInterMv(block, is_compound)) return false;
1395   ReadInterIntraMode(block, is_compound, skip_mode);
1396   ReadMotionMode(block, is_compound, skip_mode);
1397   bool is_explicit_compound_type;
1398   bool is_compound_type_average;
1399   ReadCompoundType(block, is_compound, skip_mode, &is_explicit_compound_type,
1400                    &is_compound_type_average);
1401   SetCdfContextCompoundType(block, is_explicit_compound_type,
1402                             is_compound_type_average);
1403   ReadInterpolationFilter(block, skip_mode);
1404   return true;
1405 }
1406 
SetCdfContextSkipMode(const Block & block,bool skip_mode)1407 void Tile::SetCdfContextSkipMode(const Block& block, bool skip_mode) {
1408   memset(left_context_.skip_mode + block.left_context_index,
1409          static_cast<int>(skip_mode), block.height4x4);
1410   memset(block.top_context->skip_mode + block.top_context_index,
1411          static_cast<int>(skip_mode), block.width4x4);
1412 }
1413 
DecodeInterModeInfo(const Block & block)1414 bool Tile::DecodeInterModeInfo(const Block& block) {
1415   BlockParameters& bp = *block.bp;
1416   block.bp->prediction_parameters->use_intra_block_copy = false;
1417   bp.skip = false;
1418   if (!ReadInterSegmentId(block, /*pre_skip=*/true)) return false;
1419   bool skip_mode = ReadSkipMode(block);
1420   SetCdfContextSkipMode(block, skip_mode);
1421   if (skip_mode) {
1422     bp.skip = true;
1423   } else {
1424     ReadSkip(block);
1425   }
1426   if (!frame_header_.segmentation.segment_id_pre_skip &&
1427       !ReadInterSegmentId(block, /*pre_skip=*/false)) {
1428     return false;
1429   }
1430   ReadCdef(block);
1431   if (read_deltas_) {
1432     ReadQuantizerIndexDelta(block);
1433     ReadLoopFilterDelta(block);
1434     read_deltas_ = false;
1435   }
1436   ReadIsInter(block, skip_mode);
1437   return bp.is_inter ? ReadInterBlockModeInfo(block, skip_mode)
1438                      : ReadIntraBlockModeInfo(block, /*intra_y_mode=*/false);
1439 }
1440 
DecodeModeInfo(const Block & block)1441 bool Tile::DecodeModeInfo(const Block& block) {
1442   return IsIntraFrame(frame_header_.frame_type) ? DecodeIntraModeInfo(block)
1443                                                 : DecodeInterModeInfo(block);
1444 }
1445 
1446 }  // namespace libgav1
1447