TreeParser.cpp 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792
  1. /*
  2. * Copyright (c) 2021, Hunter Salyer <thefalsehonesty@gmail.com>
  3. * Copyright (c) 2022, Gregory Bertilson <zaggy1024@gmail.com>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <AK/Function.h>
  8. #include "Enums.h"
  9. #include "LookupTables.h"
  10. #include "Parser.h"
  11. #include "TreeParser.h"
  12. namespace Video::VP9 {
  13. template<typename T>
  14. ErrorOr<T> TreeParser::parse_tree(SyntaxElementType type)
  15. {
  16. auto tree_selection = select_tree(type);
  17. int value;
  18. if (tree_selection.is_single_value()) {
  19. value = tree_selection.single_value();
  20. } else {
  21. auto tree = tree_selection.tree();
  22. int n = 0;
  23. do {
  24. n = tree[n + TRY(m_decoder.m_bit_stream->read_bool(select_tree_probability(type, n >> 1)))];
  25. } while (n > 0);
  26. value = -n;
  27. }
  28. count_syntax_element(type, value);
  29. return static_cast<T>(value);
  30. }
  31. template ErrorOr<int> TreeParser::parse_tree(SyntaxElementType);
  32. template ErrorOr<bool> TreeParser::parse_tree(SyntaxElementType);
  33. template ErrorOr<u8> TreeParser::parse_tree(SyntaxElementType);
  34. template ErrorOr<u32> TreeParser::parse_tree(SyntaxElementType);
  35. template ErrorOr<PredictionMode> TreeParser::parse_tree(SyntaxElementType);
  36. template ErrorOr<TXSize> TreeParser::parse_tree(SyntaxElementType);
  37. template ErrorOr<InterpolationFilter> TreeParser::parse_tree(SyntaxElementType);
  38. template ErrorOr<ReferenceMode> TreeParser::parse_tree(SyntaxElementType);
  39. template ErrorOr<Token> TreeParser::parse_tree(SyntaxElementType);
  40. template ErrorOr<MvClass> TreeParser::parse_tree(SyntaxElementType);
  41. template ErrorOr<MvJoint> TreeParser::parse_tree(SyntaxElementType);
  42. template<typename OutputType>
  43. inline ErrorOr<OutputType> parse_tree_new(BitStream& bit_stream, TreeParser::TreeSelection tree_selection, Function<u8(u8)> const& probability_getter)
  44. {
  45. if (tree_selection.is_single_value())
  46. return static_cast<OutputType>(tree_selection.single_value());
  47. int const* tree = tree_selection.tree();
  48. int n = 0;
  49. do {
  50. u8 node = n >> 1;
  51. n = tree[n + TRY(bit_stream.read_bool(probability_getter(node)))];
  52. } while (n > 0);
  53. return static_cast<OutputType>(-n);
  54. }
  55. inline void increment_counter(u8& counter)
  56. {
  57. counter = min(static_cast<u32>(counter) + 1, 255);
  58. }
  59. ErrorOr<Partition> TreeParser::parse_partition(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, bool has_rows, bool has_columns, BlockSubsize block_subsize, u8 num_8x8, Vector<u8> const& above_partition_context, Vector<u8> const& left_partition_context, u32 row, u32 column, bool frame_is_intra)
  60. {
  61. // Tree array
  62. TreeParser::TreeSelection tree = { PartitionSplit };
  63. if (has_rows && has_columns)
  64. tree = { partition_tree };
  65. else if (has_rows)
  66. tree = { rows_partition_tree };
  67. else if (has_columns)
  68. tree = { cols_partition_tree };
  69. // Probability array
  70. u32 above = 0;
  71. u32 left = 0;
  72. auto bsl = mi_width_log2_lookup[block_subsize];
  73. auto block_offset = mi_width_log2_lookup[Block_64x64] - bsl;
  74. for (auto i = 0; i < num_8x8; i++) {
  75. above |= above_partition_context[column + i];
  76. left |= left_partition_context[row + i];
  77. }
  78. above = (above & (1 << block_offset)) > 0;
  79. left = (left & (1 << block_offset)) > 0;
  80. auto context = bsl * 4 + left * 2 + above;
  81. u8 const* probabilities = frame_is_intra ? probability_table.kf_partition_probs()[context] : probability_table.partition_probs()[context];
  82. Function<u8(u8)> probability_getter = [&](u8 node) {
  83. if (has_rows && has_columns)
  84. return probabilities[node];
  85. if (has_columns)
  86. return probabilities[1];
  87. return probabilities[2];
  88. };
  89. auto value = TRY(parse_tree_new<Partition>(bit_stream, tree, probability_getter));
  90. increment_counter(counter.m_counts_partition[context][value]);
  91. return value;
  92. }
  93. ErrorOr<PredictionMode> TreeParser::parse_default_intra_mode(BitStream& bit_stream, ProbabilityTables const& probability_table, BlockSubsize mi_size, Optional<Array<PredictionMode, 4> const&> above_context, Optional<Array<PredictionMode, 4> const&> left_context, PredictionMode block_sub_modes[4], u8 index_x, u8 index_y)
  94. {
  95. // FIXME: This should use a struct for the above and left contexts.
  96. // Tree
  97. TreeParser::TreeSelection tree = { intra_mode_tree };
  98. // Probabilities
  99. PredictionMode above_mode, left_mode;
  100. if (mi_size >= Block_8x8) {
  101. above_mode = above_context.has_value() ? above_context.value()[2] : PredictionMode::DcPred;
  102. left_mode = left_context.has_value() ? left_context.value()[1] : PredictionMode::DcPred;
  103. } else {
  104. if (index_y > 0)
  105. above_mode = block_sub_modes[index_x];
  106. else
  107. above_mode = above_context.has_value() ? above_context.value()[2 + index_x] : PredictionMode::DcPred;
  108. if (index_x > 0)
  109. left_mode = block_sub_modes[index_y << 1];
  110. else
  111. left_mode = left_context.has_value() ? left_context.value()[1 + (index_y << 1)] : PredictionMode::DcPred;
  112. }
  113. u8 const* probabilities = probability_table.kf_y_mode_probs()[to_underlying(above_mode)][to_underlying(left_mode)];
  114. auto value = TRY(parse_tree_new<PredictionMode>(bit_stream, tree, [&](u8 node) { return probabilities[node]; }));
  115. // Default intra mode is not counted.
  116. return value;
  117. }
  118. ErrorOr<PredictionMode> TreeParser::parse_default_uv_mode(BitStream& bit_stream, ProbabilityTables const& probability_table, PredictionMode y_mode)
  119. {
  120. // Tree
  121. TreeParser::TreeSelection tree = { intra_mode_tree };
  122. // Probabilities
  123. u8 const* probabilities = probability_table.kf_uv_mode_prob()[to_underlying(y_mode)];
  124. auto value = TRY(parse_tree_new<PredictionMode>(bit_stream, tree, [&](u8 node) { return probabilities[node]; }));
  125. // Default UV mode is not counted.
  126. return value;
  127. }
  128. ErrorOr<PredictionMode> TreeParser::parse_intra_mode(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, BlockSubsize mi_size)
  129. {
  130. // Tree
  131. TreeParser::TreeSelection tree = { intra_mode_tree };
  132. // Probabilities
  133. auto context = size_group_lookup[mi_size];
  134. u8 const* probabilities = probability_table.y_mode_probs()[context];
  135. auto value = TRY(parse_tree_new<PredictionMode>(bit_stream, tree, [&](u8 node) { return probabilities[node]; }));
  136. increment_counter(counter.m_counts_intra_mode[context][to_underlying(value)]);
  137. return value;
  138. }
  139. ErrorOr<PredictionMode> TreeParser::parse_sub_intra_mode(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter)
  140. {
  141. // Tree
  142. TreeParser::TreeSelection tree = { intra_mode_tree };
  143. // Probabilities
  144. u8 const* probabilities = probability_table.y_mode_probs()[0];
  145. auto value = TRY(parse_tree_new<PredictionMode>(bit_stream, tree, [&](u8 node) { return probabilities[node]; }));
  146. increment_counter(counter.m_counts_intra_mode[0][to_underlying(value)]);
  147. return value;
  148. }
  149. ErrorOr<PredictionMode> TreeParser::parse_uv_mode(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, PredictionMode y_mode)
  150. {
  151. // Tree
  152. TreeParser::TreeSelection tree = { intra_mode_tree };
  153. // Probabilities
  154. u8 const* probabilities = probability_table.uv_mode_probs()[to_underlying(y_mode)];
  155. auto value = TRY(parse_tree_new<PredictionMode>(bit_stream, tree, [&](u8 node) { return probabilities[node]; }));
  156. increment_counter(counter.m_counts_uv_mode[to_underlying(y_mode)][to_underlying(value)]);
  157. return value;
  158. }
  159. ErrorOr<PredictionMode> TreeParser::parse_inter_mode(BitStream& bit_stream, ProbabilityTables const& probability_table, SyntaxElementCounter& counter, u8 mode_context_for_ref_frame_0)
  160. {
  161. // Tree
  162. TreeParser::TreeSelection tree = { inter_mode_tree };
  163. // Probabilities
  164. u8 const* probabilities = probability_table.inter_mode_probs()[mode_context_for_ref_frame_0];
  165. auto value = TRY(parse_tree_new<PredictionMode>(bit_stream, tree, [&](u8 node) { return probabilities[node]; }));
  166. increment_counter(counter.m_counts_inter_mode[mode_context_for_ref_frame_0][to_underlying(value) - to_underlying(PredictionMode::NearestMv)]);
  167. return value;
  168. }
  169. /*
  170. * Select a tree value based on the type of syntax element being parsed, as well as some parser state, as specified in section 9.3.1
  171. */
  172. TreeParser::TreeSelection TreeParser::select_tree(SyntaxElementType type)
  173. {
  174. switch (type) {
  175. case SyntaxElementType::SegmentID:
  176. return { segment_tree };
  177. case SyntaxElementType::Skip:
  178. case SyntaxElementType::SegIDPredicted:
  179. case SyntaxElementType::IsInter:
  180. case SyntaxElementType::CompMode:
  181. case SyntaxElementType::CompRef:
  182. case SyntaxElementType::SingleRefP1:
  183. case SyntaxElementType::SingleRefP2:
  184. case SyntaxElementType::MVSign:
  185. case SyntaxElementType::MVClass0Bit:
  186. case SyntaxElementType::MVBit:
  187. case SyntaxElementType::MoreCoefs:
  188. return { binary_tree };
  189. case SyntaxElementType::TXSize:
  190. if (m_decoder.m_max_tx_size == TX_32x32)
  191. return { tx_size_32_tree };
  192. if (m_decoder.m_max_tx_size == TX_16x16)
  193. return { tx_size_16_tree };
  194. return { tx_size_8_tree };
  195. case SyntaxElementType::InterpFilter:
  196. return { interp_filter_tree };
  197. case SyntaxElementType::MVJoint:
  198. return { mv_joint_tree };
  199. case SyntaxElementType::MVClass:
  200. return { mv_class_tree };
  201. case SyntaxElementType::MVClass0FR:
  202. case SyntaxElementType::MVFR:
  203. return { mv_fr_tree };
  204. case SyntaxElementType::MVClass0HP:
  205. case SyntaxElementType::MVHP:
  206. if (m_decoder.m_use_hp)
  207. return { binary_tree };
  208. return { 1 };
  209. case SyntaxElementType::Token:
  210. return { token_tree };
  211. default:
  212. break;
  213. }
  214. VERIFY_NOT_REACHED();
  215. }
  216. /*
  217. * Select a probability with which to read a boolean when decoding a tree, as specified in section 9.3.2
  218. */
  219. u8 TreeParser::select_tree_probability(SyntaxElementType type, u8 node)
  220. {
  221. switch (type) {
  222. case SyntaxElementType::SegmentID:
  223. return calculate_segment_id_probability(node);
  224. case SyntaxElementType::Skip:
  225. return calculate_skip_probability();
  226. case SyntaxElementType::SegIDPredicted:
  227. return calculate_seg_id_predicted_probability();
  228. case SyntaxElementType::IsInter:
  229. return calculate_is_inter_probability();
  230. case SyntaxElementType::CompMode:
  231. return calculate_comp_mode_probability();
  232. case SyntaxElementType::CompRef:
  233. return calculate_comp_ref_probability();
  234. case SyntaxElementType::SingleRefP1:
  235. return calculate_single_ref_p1_probability();
  236. case SyntaxElementType::SingleRefP2:
  237. return calculate_single_ref_p2_probability();
  238. case SyntaxElementType::MVSign:
  239. return m_decoder.m_probability_tables->mv_sign_prob()[m_mv_component];
  240. case SyntaxElementType::MVClass0Bit:
  241. return m_decoder.m_probability_tables->mv_class0_bit_prob()[m_mv_component];
  242. case SyntaxElementType::MVBit:
  243. VERIFY(m_mv_bit < MV_OFFSET_BITS);
  244. return m_decoder.m_probability_tables->mv_bits_prob()[m_mv_component][m_mv_bit];
  245. case SyntaxElementType::TXSize:
  246. return calculate_tx_size_probability(node);
  247. case SyntaxElementType::InterpFilter:
  248. return calculate_interp_filter_probability(node);
  249. case SyntaxElementType::MVJoint:
  250. return m_decoder.m_probability_tables->mv_joint_probs()[node];
  251. case SyntaxElementType::MVClass:
  252. // Spec doesn't mention node, but the probabilities table has an extra dimension
  253. // so we will use node for that.
  254. return m_decoder.m_probability_tables->mv_class_probs()[m_mv_component][node];
  255. case SyntaxElementType::MVClass0FR:
  256. VERIFY(m_mv_class0_bit < CLASS0_SIZE);
  257. return m_decoder.m_probability_tables->mv_class0_fr_probs()[m_mv_component][m_mv_class0_bit][node];
  258. case SyntaxElementType::MVClass0HP:
  259. return m_decoder.m_probability_tables->mv_class0_hp_prob()[m_mv_component];
  260. case SyntaxElementType::MVFR:
  261. return m_decoder.m_probability_tables->mv_fr_probs()[m_mv_component][node];
  262. case SyntaxElementType::MVHP:
  263. return m_decoder.m_probability_tables->mv_hp_prob()[m_mv_component];
  264. case SyntaxElementType::Token:
  265. return calculate_token_probability(node);
  266. case SyntaxElementType::MoreCoefs:
  267. return calculate_more_coefs_probability();
  268. default:
  269. break;
  270. }
  271. VERIFY_NOT_REACHED();
  272. }
  273. #define ABOVE_FRAME_0 m_decoder.m_above_ref_frame[0]
  274. #define ABOVE_FRAME_1 m_decoder.m_above_ref_frame[1]
  275. #define LEFT_FRAME_0 m_decoder.m_left_ref_frame[0]
  276. #define LEFT_FRAME_1 m_decoder.m_left_ref_frame[1]
  277. #define AVAIL_U m_decoder.m_available_u
  278. #define AVAIL_L m_decoder.m_available_l
  279. #define ABOVE_INTRA m_decoder.m_above_intra
  280. #define LEFT_INTRA m_decoder.m_left_intra
  281. #define ABOVE_SINGLE m_decoder.m_above_single
  282. #define LEFT_SINGLE m_decoder.m_left_single
  283. u8 TreeParser::calculate_segment_id_probability(u8 node)
  284. {
  285. return m_decoder.m_segmentation_tree_probs[node];
  286. }
  287. u8 TreeParser::calculate_skip_probability()
  288. {
  289. m_ctx = 0;
  290. if (AVAIL_U)
  291. m_ctx += m_decoder.m_skips[(m_decoder.m_mi_row - 1) * m_decoder.m_mi_cols + m_decoder.m_mi_col];
  292. if (AVAIL_L)
  293. m_ctx += m_decoder.m_skips[m_decoder.m_mi_row * m_decoder.m_mi_cols + m_decoder.m_mi_col - 1];
  294. return m_decoder.m_probability_tables->skip_prob()[m_ctx];
  295. }
  296. u8 TreeParser::calculate_seg_id_predicted_probability()
  297. {
  298. m_ctx = m_decoder.m_left_seg_pred_context[m_decoder.m_mi_row] + m_decoder.m_above_seg_pred_context[m_decoder.m_mi_col];
  299. return m_decoder.m_segmentation_pred_prob[m_ctx];
  300. }
  301. u8 TreeParser::calculate_is_inter_probability()
  302. {
  303. if (AVAIL_U && AVAIL_L) {
  304. m_ctx = (LEFT_INTRA && ABOVE_INTRA) ? 3 : LEFT_INTRA || ABOVE_INTRA;
  305. } else if (AVAIL_U || AVAIL_L) {
  306. m_ctx = 2 * (AVAIL_U ? ABOVE_INTRA : LEFT_INTRA);
  307. } else {
  308. m_ctx = 0;
  309. }
  310. return m_decoder.m_probability_tables->is_inter_prob()[m_ctx];
  311. }
  312. u8 TreeParser::calculate_comp_mode_probability()
  313. {
  314. if (AVAIL_U && AVAIL_L) {
  315. if (ABOVE_SINGLE && LEFT_SINGLE) {
  316. auto is_above_fixed = ABOVE_FRAME_0 == m_decoder.m_comp_fixed_ref;
  317. auto is_left_fixed = LEFT_FRAME_0 == m_decoder.m_comp_fixed_ref;
  318. m_ctx = is_above_fixed ^ is_left_fixed;
  319. } else if (ABOVE_SINGLE) {
  320. auto is_above_fixed = ABOVE_FRAME_0 == m_decoder.m_comp_fixed_ref;
  321. m_ctx = 2 + (is_above_fixed || ABOVE_INTRA);
  322. } else if (LEFT_SINGLE) {
  323. auto is_left_fixed = LEFT_FRAME_0 == m_decoder.m_comp_fixed_ref;
  324. m_ctx = 2 + (is_left_fixed || LEFT_INTRA);
  325. } else {
  326. m_ctx = 4;
  327. }
  328. } else if (AVAIL_U) {
  329. if (ABOVE_SINGLE) {
  330. m_ctx = ABOVE_FRAME_0 == m_decoder.m_comp_fixed_ref;
  331. } else {
  332. m_ctx = 3;
  333. }
  334. } else if (AVAIL_L) {
  335. if (LEFT_SINGLE) {
  336. m_ctx = LEFT_FRAME_0 == m_decoder.m_comp_fixed_ref;
  337. } else {
  338. m_ctx = 3;
  339. }
  340. } else {
  341. m_ctx = 1;
  342. }
  343. return m_decoder.m_probability_tables->comp_mode_prob()[m_ctx];
  344. }
  345. u8 TreeParser::calculate_comp_ref_probability()
  346. {
  347. auto fix_ref_idx = m_decoder.m_ref_frame_sign_bias[m_decoder.m_comp_fixed_ref];
  348. auto var_ref_idx = !fix_ref_idx;
  349. if (AVAIL_U && AVAIL_L) {
  350. if (ABOVE_INTRA && LEFT_INTRA) {
  351. m_ctx = 2;
  352. } else if (LEFT_INTRA) {
  353. if (ABOVE_SINGLE) {
  354. m_ctx = 1 + 2 * (ABOVE_FRAME_0 != m_decoder.m_comp_var_ref[1]);
  355. } else {
  356. m_ctx = 1 + 2 * (m_decoder.m_above_ref_frame[var_ref_idx] != m_decoder.m_comp_var_ref[1]);
  357. }
  358. } else if (ABOVE_INTRA) {
  359. if (LEFT_SINGLE) {
  360. m_ctx = 1 + 2 * (LEFT_FRAME_0 != m_decoder.m_comp_var_ref[1]);
  361. } else {
  362. m_ctx = 1 + 2 * (m_decoder.m_left_ref_frame[var_ref_idx] != m_decoder.m_comp_var_ref[1]);
  363. }
  364. } else {
  365. auto var_ref_above = m_decoder.m_above_ref_frame[ABOVE_SINGLE ? 0 : var_ref_idx];
  366. auto var_ref_left = m_decoder.m_left_ref_frame[LEFT_SINGLE ? 0 : var_ref_idx];
  367. if (var_ref_above == var_ref_left && m_decoder.m_comp_var_ref[1] == var_ref_above) {
  368. m_ctx = 0;
  369. } else if (LEFT_SINGLE && ABOVE_SINGLE) {
  370. if ((var_ref_above == m_decoder.m_comp_fixed_ref && var_ref_left == m_decoder.m_comp_var_ref[0])
  371. || (var_ref_left == m_decoder.m_comp_fixed_ref && var_ref_above == m_decoder.m_comp_var_ref[0])) {
  372. m_ctx = 4;
  373. } else if (var_ref_above == var_ref_left) {
  374. m_ctx = 3;
  375. } else {
  376. m_ctx = 1;
  377. }
  378. } else if (LEFT_SINGLE || ABOVE_SINGLE) {
  379. auto vrfc = LEFT_SINGLE ? var_ref_above : var_ref_left;
  380. auto rfs = ABOVE_SINGLE ? var_ref_above : var_ref_left;
  381. if (vrfc == m_decoder.m_comp_var_ref[1] && rfs != m_decoder.m_comp_var_ref[1]) {
  382. m_ctx = 1;
  383. } else if (rfs == m_decoder.m_comp_var_ref[1] && vrfc != m_decoder.m_comp_var_ref[1]) {
  384. m_ctx = 2;
  385. } else {
  386. m_ctx = 4;
  387. }
  388. } else if (var_ref_above == var_ref_left) {
  389. m_ctx = 4;
  390. } else {
  391. m_ctx = 2;
  392. }
  393. }
  394. } else if (AVAIL_U) {
  395. if (ABOVE_INTRA) {
  396. m_ctx = 2;
  397. } else {
  398. if (ABOVE_SINGLE) {
  399. m_ctx = 3 * (ABOVE_FRAME_0 != m_decoder.m_comp_var_ref[1]);
  400. } else {
  401. m_ctx = 4 * (m_decoder.m_above_ref_frame[var_ref_idx] != m_decoder.m_comp_var_ref[1]);
  402. }
  403. }
  404. } else if (AVAIL_L) {
  405. if (LEFT_INTRA) {
  406. m_ctx = 2;
  407. } else {
  408. if (LEFT_SINGLE) {
  409. m_ctx = 3 * (LEFT_FRAME_0 != m_decoder.m_comp_var_ref[1]);
  410. } else {
  411. m_ctx = 4 * (m_decoder.m_left_ref_frame[var_ref_idx] != m_decoder.m_comp_var_ref[1]);
  412. }
  413. }
  414. } else {
  415. m_ctx = 2;
  416. }
  417. return m_decoder.m_probability_tables->comp_ref_prob()[m_ctx];
  418. }
  419. u8 TreeParser::calculate_single_ref_p1_probability()
  420. {
  421. if (AVAIL_U && AVAIL_L) {
  422. if (ABOVE_INTRA && LEFT_INTRA) {
  423. m_ctx = 2;
  424. } else if (LEFT_INTRA) {
  425. if (ABOVE_SINGLE) {
  426. m_ctx = 4 * (ABOVE_FRAME_0 == LastFrame);
  427. } else {
  428. m_ctx = 1 + (ABOVE_FRAME_0 == LastFrame || ABOVE_FRAME_1 == LastFrame);
  429. }
  430. } else if (ABOVE_INTRA) {
  431. if (LEFT_SINGLE) {
  432. m_ctx = 4 * (LEFT_FRAME_0 == LastFrame);
  433. } else {
  434. m_ctx = 1 + (LEFT_FRAME_0 == LastFrame || LEFT_FRAME_1 == LastFrame);
  435. }
  436. } else {
  437. if (LEFT_SINGLE && ABOVE_SINGLE) {
  438. m_ctx = 2 * (ABOVE_FRAME_0 == LastFrame) + 2 * (LEFT_FRAME_0 == LastFrame);
  439. } else if (!LEFT_SINGLE && !ABOVE_SINGLE) {
  440. auto above_is_last = ABOVE_FRAME_0 == LastFrame || ABOVE_FRAME_1 == LastFrame;
  441. auto left_is_last = LEFT_FRAME_0 == LastFrame || LEFT_FRAME_1 == LastFrame;
  442. m_ctx = 1 + (above_is_last || left_is_last);
  443. } else {
  444. auto rfs = ABOVE_SINGLE ? ABOVE_FRAME_0 : LEFT_FRAME_0;
  445. auto crf1 = ABOVE_SINGLE ? LEFT_FRAME_0 : ABOVE_FRAME_0;
  446. auto crf2 = ABOVE_SINGLE ? LEFT_FRAME_1 : ABOVE_FRAME_1;
  447. m_ctx = crf1 == LastFrame || crf2 == LastFrame;
  448. if (rfs == LastFrame)
  449. m_ctx += 3;
  450. }
  451. }
  452. } else if (AVAIL_U) {
  453. if (ABOVE_INTRA) {
  454. m_ctx = 2;
  455. } else {
  456. if (ABOVE_SINGLE) {
  457. m_ctx = 4 * (ABOVE_FRAME_0 == LastFrame);
  458. } else {
  459. m_ctx = 1 + (ABOVE_FRAME_0 == LastFrame || ABOVE_FRAME_1 == LastFrame);
  460. }
  461. }
  462. } else if (AVAIL_L) {
  463. if (LEFT_INTRA) {
  464. m_ctx = 2;
  465. } else {
  466. if (LEFT_SINGLE) {
  467. m_ctx = 4 * (LEFT_FRAME_0 == LastFrame);
  468. } else {
  469. m_ctx = 1 + (LEFT_FRAME_0 == LastFrame || LEFT_FRAME_1 == LastFrame);
  470. }
  471. }
  472. } else {
  473. m_ctx = 2;
  474. }
  475. return m_decoder.m_probability_tables->single_ref_prob()[m_ctx][0];
  476. }
  477. u8 TreeParser::calculate_single_ref_p2_probability()
  478. {
  479. if (AVAIL_U && AVAIL_L) {
  480. if (ABOVE_INTRA && LEFT_INTRA) {
  481. m_ctx = 2;
  482. } else if (LEFT_INTRA) {
  483. if (ABOVE_SINGLE) {
  484. if (ABOVE_FRAME_0 == LastFrame) {
  485. m_ctx = 3;
  486. } else {
  487. m_ctx = 4 * (ABOVE_FRAME_0 == GoldenFrame);
  488. }
  489. } else {
  490. m_ctx = 1 + 2 * (ABOVE_FRAME_0 == GoldenFrame || ABOVE_FRAME_1 == GoldenFrame);
  491. }
  492. } else if (ABOVE_INTRA) {
  493. if (LEFT_SINGLE) {
  494. if (LEFT_FRAME_0 == LastFrame) {
  495. m_ctx = 3;
  496. } else {
  497. m_ctx = 4 * (LEFT_FRAME_0 == GoldenFrame);
  498. }
  499. } else {
  500. m_ctx = 1 + 2 * (LEFT_FRAME_0 == GoldenFrame || LEFT_FRAME_1 == GoldenFrame);
  501. }
  502. } else {
  503. if (LEFT_SINGLE && ABOVE_SINGLE) {
  504. auto above_last = ABOVE_FRAME_0 == LastFrame;
  505. auto left_last = LEFT_FRAME_0 == LastFrame;
  506. if (above_last && left_last) {
  507. m_ctx = 3;
  508. } else if (above_last) {
  509. m_ctx = 4 * (LEFT_FRAME_0 == GoldenFrame);
  510. } else if (left_last) {
  511. m_ctx = 4 * (ABOVE_FRAME_0 == GoldenFrame);
  512. } else {
  513. m_ctx = 2 * (ABOVE_FRAME_0 == GoldenFrame) + 2 * (LEFT_FRAME_0 == GoldenFrame);
  514. }
  515. } else if (!LEFT_SINGLE && !ABOVE_SINGLE) {
  516. if (ABOVE_FRAME_0 == LEFT_FRAME_0 && ABOVE_FRAME_1 == LEFT_FRAME_1) {
  517. m_ctx = 3 * (ABOVE_FRAME_0 == GoldenFrame || ABOVE_FRAME_1 == GoldenFrame);
  518. } else {
  519. m_ctx = 2;
  520. }
  521. } else {
  522. auto rfs = ABOVE_SINGLE ? ABOVE_FRAME_0 : LEFT_FRAME_0;
  523. auto crf1 = ABOVE_SINGLE ? LEFT_FRAME_0 : ABOVE_FRAME_0;
  524. auto crf2 = ABOVE_SINGLE ? LEFT_FRAME_1 : ABOVE_FRAME_1;
  525. m_ctx = crf1 == GoldenFrame || crf2 == GoldenFrame;
  526. if (rfs == GoldenFrame) {
  527. m_ctx += 3;
  528. } else if (rfs != AltRefFrame) {
  529. m_ctx = 1 + (2 * m_ctx);
  530. }
  531. }
  532. }
  533. } else if (AVAIL_U) {
  534. if (ABOVE_INTRA || (ABOVE_FRAME_0 == LastFrame && ABOVE_SINGLE)) {
  535. m_ctx = 2;
  536. } else if (ABOVE_SINGLE) {
  537. m_ctx = 4 * (ABOVE_FRAME_0 == GoldenFrame);
  538. } else {
  539. m_ctx = 3 * (ABOVE_FRAME_0 == GoldenFrame || ABOVE_FRAME_1 == GoldenFrame);
  540. }
  541. } else if (AVAIL_L) {
  542. if (LEFT_INTRA || (LEFT_FRAME_0 == LastFrame && LEFT_SINGLE)) {
  543. m_ctx = 2;
  544. } else if (LEFT_SINGLE) {
  545. m_ctx = 4 * (LEFT_FRAME_0 == GoldenFrame);
  546. } else {
  547. m_ctx = 3 * (LEFT_FRAME_0 == GoldenFrame || LEFT_FRAME_1 == GoldenFrame);
  548. }
  549. } else {
  550. m_ctx = 2;
  551. }
  552. return m_decoder.m_probability_tables->single_ref_prob()[m_ctx][1];
  553. }
  554. u8 TreeParser::calculate_tx_size_probability(u8 node)
  555. {
  556. auto above = m_decoder.m_max_tx_size;
  557. auto left = m_decoder.m_max_tx_size;
  558. if (AVAIL_U) {
  559. auto u_pos = (m_decoder.m_mi_row - 1) * m_decoder.m_mi_cols + m_decoder.m_mi_col;
  560. if (!m_decoder.m_skips[u_pos])
  561. above = m_decoder.m_tx_sizes[u_pos];
  562. }
  563. if (AVAIL_L) {
  564. auto l_pos = m_decoder.m_mi_row * m_decoder.m_mi_cols + m_decoder.m_mi_col - 1;
  565. if (!m_decoder.m_skips[l_pos])
  566. left = m_decoder.m_tx_sizes[l_pos];
  567. }
  568. if (!AVAIL_L)
  569. left = above;
  570. if (!AVAIL_U)
  571. above = left;
  572. m_ctx = (above + left) > m_decoder.m_max_tx_size;
  573. return m_decoder.m_probability_tables->tx_probs()[m_decoder.m_max_tx_size][m_ctx][node];
  574. }
  575. u8 TreeParser::calculate_interp_filter_probability(u8 node)
  576. {
  577. // NOTE: SWITCHABLE_FILTERS is not used in the spec for this function. Therefore, the number
  578. // was demystified by referencing the reference codec libvpx:
  579. // https://github.com/webmproject/libvpx/blob/705bf9de8c96cfe5301451f1d7e5c90a41c64e5f/vp9/common/vp9_pred_common.h#L69
  580. auto left_interp = (AVAIL_L && m_decoder.m_left_ref_frame[0] > IntraFrame)
  581. ? m_decoder.m_interp_filters[m_decoder.get_image_index(m_decoder.m_mi_row, m_decoder.m_mi_col - 1)]
  582. : SWITCHABLE_FILTERS;
  583. auto above_interp = (AVAIL_U && m_decoder.m_above_ref_frame[0] > IntraFrame)
  584. ? m_decoder.m_interp_filters[m_decoder.get_image_index(m_decoder.m_mi_row - 1, m_decoder.m_mi_col)]
  585. : SWITCHABLE_FILTERS;
  586. if (left_interp == above_interp)
  587. m_ctx = left_interp;
  588. else if (left_interp == SWITCHABLE_FILTERS)
  589. m_ctx = above_interp;
  590. else if (above_interp == SWITCHABLE_FILTERS)
  591. m_ctx = left_interp;
  592. else
  593. m_ctx = SWITCHABLE_FILTERS;
  594. return m_decoder.m_probability_tables->interp_filter_probs()[m_ctx][node];
  595. }
  596. void TreeParser::set_tokens_variables(u8 band, u32 c, u32 plane, TXSize tx_size, u32 pos)
  597. {
  598. m_band = band;
  599. m_c = c;
  600. m_plane = plane;
  601. m_tx_size = tx_size;
  602. m_pos = pos;
  603. if (m_c == 0) {
  604. auto sx = m_plane > 0 ? m_decoder.m_subsampling_x : 0;
  605. auto sy = m_plane > 0 ? m_decoder.m_subsampling_y : 0;
  606. auto max_x = (2 * m_decoder.m_mi_cols) >> sx;
  607. auto max_y = (2 * m_decoder.m_mi_rows) >> sy;
  608. u8 numpts = 1 << m_tx_size;
  609. auto x4 = m_start_x >> 2;
  610. auto y4 = m_start_y >> 2;
  611. u32 above = 0;
  612. u32 left = 0;
  613. for (size_t i = 0; i < numpts; i++) {
  614. if (x4 + i < max_x)
  615. above |= m_decoder.m_above_nonzero_context[m_plane][x4 + i];
  616. if (y4 + i < max_y)
  617. left |= m_decoder.m_left_nonzero_context[m_plane][y4 + i];
  618. }
  619. m_ctx = above + left;
  620. } else {
  621. u32 neighbor_0, neighbor_1;
  622. auto n = 4 << m_tx_size;
  623. auto i = m_pos / n;
  624. auto j = m_pos % n;
  625. auto a = i > 0 ? (i - 1) * n + j : 0;
  626. auto a2 = i * n + j - 1;
  627. if (i > 0 && j > 0) {
  628. if (m_decoder.m_tx_type == DCT_ADST) {
  629. neighbor_0 = a;
  630. neighbor_1 = a;
  631. } else if (m_decoder.m_tx_type == ADST_DCT) {
  632. neighbor_0 = a2;
  633. neighbor_1 = a2;
  634. } else {
  635. neighbor_0 = a;
  636. neighbor_1 = a2;
  637. }
  638. } else if (i > 0) {
  639. neighbor_0 = a;
  640. neighbor_1 = a;
  641. } else {
  642. neighbor_0 = a2;
  643. neighbor_1 = a2;
  644. }
  645. m_ctx = (1 + m_decoder.m_token_cache[neighbor_0] + m_decoder.m_token_cache[neighbor_1]) >> 1;
  646. }
  647. }
  648. u8 TreeParser::calculate_more_coefs_probability()
  649. {
  650. return m_decoder.m_probability_tables->coef_probs()[m_tx_size][m_plane > 0][m_decoder.m_is_inter][m_band][m_ctx][0];
  651. }
  652. u8 TreeParser::calculate_token_probability(u8 node)
  653. {
  654. auto prob = m_decoder.m_probability_tables->coef_probs()[m_tx_size][m_plane > 0][m_decoder.m_is_inter][m_band][m_ctx][min(2, 1 + node)];
  655. if (node < 2)
  656. return prob;
  657. auto x = (prob - 1) / 2;
  658. auto& pareto_table = m_decoder.m_probability_tables->pareto_table();
  659. if (prob & 1)
  660. return pareto_table[x][node - 2];
  661. return (pareto_table[x][node - 2] + pareto_table[x + 1][node - 2]) >> 1;
  662. }
  663. void TreeParser::count_syntax_element(SyntaxElementType type, int value)
  664. {
  665. auto increment = [](u8& count) {
  666. increment_counter(count);
  667. };
  668. switch (type) {
  669. case SyntaxElementType::Skip:
  670. increment(m_decoder.m_syntax_element_counter->m_counts_skip[m_ctx][value]);
  671. return;
  672. case SyntaxElementType::IsInter:
  673. increment(m_decoder.m_syntax_element_counter->m_counts_is_inter[m_ctx][value]);
  674. return;
  675. case SyntaxElementType::CompMode:
  676. increment(m_decoder.m_syntax_element_counter->m_counts_comp_mode[m_ctx][value]);
  677. return;
  678. case SyntaxElementType::CompRef:
  679. increment(m_decoder.m_syntax_element_counter->m_counts_comp_ref[m_ctx][value]);
  680. return;
  681. case SyntaxElementType::SingleRefP1:
  682. increment(m_decoder.m_syntax_element_counter->m_counts_single_ref[m_ctx][0][value]);
  683. return;
  684. case SyntaxElementType::SingleRefP2:
  685. increment(m_decoder.m_syntax_element_counter->m_counts_single_ref[m_ctx][1][value]);
  686. return;
  687. case SyntaxElementType::MVSign:
  688. increment(m_decoder.m_syntax_element_counter->m_counts_mv_sign[m_mv_component][value]);
  689. return;
  690. case SyntaxElementType::MVClass0Bit:
  691. increment(m_decoder.m_syntax_element_counter->m_counts_mv_class0_bit[m_mv_component][value]);
  692. return;
  693. case SyntaxElementType::MVBit:
  694. VERIFY(m_mv_bit < MV_OFFSET_BITS);
  695. increment(m_decoder.m_syntax_element_counter->m_counts_mv_bits[m_mv_component][m_mv_bit][value]);
  696. m_mv_bit = 0xFF;
  697. return;
  698. case SyntaxElementType::TXSize:
  699. increment(m_decoder.m_syntax_element_counter->m_counts_tx_size[m_decoder.m_max_tx_size][m_ctx][value]);
  700. return;
  701. case SyntaxElementType::InterpFilter:
  702. increment(m_decoder.m_syntax_element_counter->m_counts_interp_filter[m_ctx][value]);
  703. return;
  704. case SyntaxElementType::MVJoint:
  705. increment(m_decoder.m_syntax_element_counter->m_counts_mv_joint[value]);
  706. return;
  707. case SyntaxElementType::MVClass:
  708. increment(m_decoder.m_syntax_element_counter->m_counts_mv_class[m_mv_component][value]);
  709. return;
  710. case SyntaxElementType::MVClass0FR:
  711. VERIFY(m_mv_class0_bit < CLASS0_SIZE);
  712. increment(m_decoder.m_syntax_element_counter->m_counts_mv_class0_fr[m_mv_component][m_mv_class0_bit][value]);
  713. m_mv_class0_bit = 0xFF;
  714. return;
  715. case SyntaxElementType::MVClass0HP:
  716. increment(m_decoder.m_syntax_element_counter->m_counts_mv_class0_hp[m_mv_component][value]);
  717. return;
  718. case SyntaxElementType::MVFR:
  719. increment(m_decoder.m_syntax_element_counter->m_counts_mv_fr[m_mv_component][value]);
  720. return;
  721. case SyntaxElementType::MVHP:
  722. increment(m_decoder.m_syntax_element_counter->m_counts_mv_hp[m_mv_component][value]);
  723. return;
  724. case SyntaxElementType::Token:
  725. increment(m_decoder.m_syntax_element_counter->m_counts_token[m_tx_size][m_plane > 0][m_decoder.m_is_inter][m_band][m_ctx][min(2, value)]);
  726. return;
  727. case SyntaxElementType::MoreCoefs:
  728. increment(m_decoder.m_syntax_element_counter->m_counts_more_coefs[m_tx_size][m_plane > 0][m_decoder.m_is_inter][m_band][m_ctx][value]);
  729. return;
  730. case SyntaxElementType::SegmentID:
  731. case SyntaxElementType::SegIDPredicted:
  732. // No counting required
  733. return;
  734. default:
  735. break;
  736. }
  737. VERIFY_NOT_REACHED();
  738. }
  739. }