Decoder.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414
  1. /*
  2. * Copyright (c) 2021, Hunter Salyer <thefalsehonesty@gmail.com>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include "Decoder.h"
  7. namespace Video::VP9 {
  8. #define RESERVED_ZERO \
  9. if (m_bit_stream->read_bit() != 0) \
  10. return false
  11. Decoder::Decoder()
  12. {
  13. m_probability_tables = make<ProbabilityTables>();
  14. }
  15. bool Decoder::parse_frame(const ByteBuffer& frame_data)
  16. {
  17. m_bit_stream = make<BitStream>(frame_data.data(), frame_data.size());
  18. m_syntax_element_counter = make<SyntaxElementCounter>();
  19. m_start_bit_pos = m_bit_stream->get_position();
  20. if (!uncompressed_header())
  21. return false;
  22. dbgln("Finished reading uncompressed header");
  23. if (!trailing_bits())
  24. return false;
  25. if (m_header_size_in_bytes == 0) {
  26. // FIXME: Do we really need to read all of these bits?
  27. // while (m_bit_stream->get_position() < m_start_bit_pos + (8 * frame_data.size()))
  28. // RESERVED_ZERO;
  29. dbgln("No header");
  30. return true;
  31. }
  32. m_probability_tables->load_probs(m_frame_context_idx);
  33. m_probability_tables->load_probs2(m_frame_context_idx);
  34. m_syntax_element_counter->clear_counts();
  35. return true;
  36. }
  37. bool Decoder::uncompressed_header()
  38. {
  39. auto frame_marker = m_bit_stream->read_f(2);
  40. if (frame_marker != 2)
  41. return false;
  42. auto profile_low_bit = m_bit_stream->read_bit();
  43. auto profile_high_bit = m_bit_stream->read_bit();
  44. m_profile = (profile_high_bit << 1u) + profile_low_bit;
  45. if (m_profile == 3)
  46. RESERVED_ZERO;
  47. auto show_existing_frame = m_bit_stream->read_bit();
  48. if (show_existing_frame) {
  49. m_frame_to_show_map_index = m_bit_stream->read_f(3);
  50. m_header_size_in_bytes = 0;
  51. m_refresh_frame_flags = 0;
  52. m_loop_filter_level = 0;
  53. return true;
  54. }
  55. m_last_frame_type = m_frame_type;
  56. m_frame_type = read_frame_type();
  57. m_show_frame = m_bit_stream->read_bit();
  58. m_error_resilient_mode = m_bit_stream->read_bit();
  59. if (m_frame_type == KeyFrame) {
  60. if (!frame_sync_code())
  61. return false;
  62. if (!color_config())
  63. return false;
  64. if (!frame_size())
  65. return false;
  66. if (!render_size())
  67. return false;
  68. m_refresh_frame_flags = 0xFF;
  69. m_frame_is_intra = true;
  70. } else {
  71. m_frame_is_intra = !m_show_frame && m_bit_stream->read_bit();
  72. if (!m_error_resilient_mode) {
  73. m_reset_frame_context = m_bit_stream->read_f(2);
  74. } else {
  75. m_reset_frame_context = 0;
  76. }
  77. if (m_frame_is_intra) {
  78. if (!frame_sync_code())
  79. return false;
  80. if (m_profile > 0) {
  81. if (!color_config())
  82. return false;
  83. } else {
  84. m_color_space = Bt601;
  85. m_subsampling_x = true;
  86. m_subsampling_y = true;
  87. m_bit_depth = 8;
  88. }
  89. m_refresh_frame_flags = m_bit_stream->read_f8();
  90. if (!frame_size())
  91. return false;
  92. if (!render_size())
  93. return false;
  94. } else {
  95. m_refresh_frame_flags = m_bit_stream->read_f8();
  96. for (auto i = 0; i < 3; i++) {
  97. m_ref_frame_idx[i] = m_bit_stream->read_f(3);
  98. m_ref_frame_sign_bias[LastFrame + i] = m_bit_stream->read_bit();
  99. }
  100. frame_size_with_refs();
  101. m_allow_high_precision_mv = m_bit_stream->read_bit();
  102. read_interpolation_filter();
  103. }
  104. }
  105. if (!m_error_resilient_mode) {
  106. m_refresh_frame_context = m_bit_stream->read_bit();
  107. m_frame_parallel_decoding_mode = m_bit_stream->read_bit();
  108. } else {
  109. m_refresh_frame_context = false;
  110. m_frame_parallel_decoding_mode = true;
  111. }
  112. m_frame_context_idx = m_bit_stream->read_f(2);
  113. if (m_frame_is_intra || m_error_resilient_mode) {
  114. setup_past_independence();
  115. if (m_frame_type == KeyFrame || m_error_resilient_mode || m_reset_frame_context == 3) {
  116. for (auto i = 0; i < 4; i++) {
  117. m_probability_tables->save_probs(i);
  118. }
  119. } else if (m_reset_frame_context == 2) {
  120. m_probability_tables->save_probs(m_frame_context_idx);
  121. }
  122. m_frame_context_idx = 0;
  123. }
  124. loop_filter_params();
  125. quantization_params();
  126. segmentation_params();
  127. tile_info();
  128. m_header_size_in_bytes = m_bit_stream->read_f16();
  129. return true;
  130. }
  131. bool Decoder::frame_sync_code()
  132. {
  133. if (m_bit_stream->read_byte() != 0x49)
  134. return false;
  135. if (m_bit_stream->read_byte() != 0x83)
  136. return false;
  137. return m_bit_stream->read_byte() == 0x42;
  138. }
  139. bool Decoder::color_config()
  140. {
  141. if (m_profile >= 2) {
  142. m_bit_depth = m_bit_stream->read_bit() ? 12 : 10;
  143. } else {
  144. m_bit_depth = 8;
  145. }
  146. auto color_space = m_bit_stream->read_f(3);
  147. if (color_space > RGB)
  148. return false;
  149. m_color_space = static_cast<ColorSpace>(color_space);
  150. if (color_space != RGB) {
  151. m_color_range = read_color_range();
  152. if (m_profile == 1 || m_profile == 3) {
  153. m_subsampling_x = m_bit_stream->read_bit();
  154. m_subsampling_y = m_bit_stream->read_bit();
  155. RESERVED_ZERO;
  156. } else {
  157. m_subsampling_x = true;
  158. m_subsampling_y = true;
  159. }
  160. } else {
  161. m_color_range = FullSwing;
  162. if (m_profile == 1 || m_profile == 3) {
  163. m_subsampling_x = false;
  164. m_subsampling_y = false;
  165. RESERVED_ZERO;
  166. }
  167. }
  168. return true;
  169. }
  170. bool Decoder::frame_size()
  171. {
  172. m_frame_width = m_bit_stream->read_f16() + 1;
  173. m_frame_height = m_bit_stream->read_f16() + 1;
  174. compute_image_size();
  175. return true;
  176. }
  177. bool Decoder::render_size()
  178. {
  179. if (m_bit_stream->read_bit()) {
  180. m_render_width = m_bit_stream->read_f16() + 1;
  181. m_render_height = m_bit_stream->read_f16() + 1;
  182. } else {
  183. m_render_width = m_frame_width;
  184. m_render_height = m_frame_height;
  185. }
  186. return true;
  187. }
  188. bool Decoder::frame_size_with_refs()
  189. {
  190. bool found_ref;
  191. for (auto i = 0; i < 3; i++) {
  192. found_ref = m_bit_stream->read_bit();
  193. if (found_ref) {
  194. // TODO:
  195. // - FrameWidth = RefFrameWidth[ref_frame_idx[ i] ];
  196. // - FrameHeight = RefFrameHeight[ref_frame_idx[ i] ];
  197. break;
  198. }
  199. }
  200. if (!found_ref)
  201. frame_size();
  202. else
  203. compute_image_size();
  204. render_size();
  205. return true;
  206. }
  207. bool Decoder::compute_image_size()
  208. {
  209. m_mi_cols = (m_frame_width + 7u) >> 3u;
  210. m_mi_rows = (m_frame_height + 7u) >> 3u;
  211. m_sb64_cols = (m_mi_cols + 7u) >> 3u;
  212. m_sb64_rows = (m_mi_rows + 7u) >> 3u;
  213. return true;
  214. }
  215. bool Decoder::read_interpolation_filter()
  216. {
  217. if (m_bit_stream->read_bit()) {
  218. m_interpolation_filter = Switchable;
  219. } else {
  220. m_interpolation_filter = literal_to_type[m_bit_stream->read_f(2)];
  221. }
  222. return true;
  223. }
  224. bool Decoder::loop_filter_params()
  225. {
  226. m_loop_filter_level = m_bit_stream->read_f(6);
  227. m_loop_filter_sharpness = m_bit_stream->read_f(3);
  228. m_loop_filter_delta_enabled = m_bit_stream->read_bit();
  229. if (m_loop_filter_delta_enabled) {
  230. if (m_bit_stream->read_bit()) {
  231. for (auto i = 0; i < 4; i++) {
  232. if (m_bit_stream->read_bit()) {
  233. // TODO: loop_filter_ref_deltas[i] = s(6);
  234. }
  235. }
  236. for (auto i = 0; i < 2; i++) {
  237. if (m_bit_stream->read_bit()) {
  238. // TODO: loop_filter_mode_deltas[i] = s(6);
  239. }
  240. }
  241. }
  242. }
  243. return true;
  244. }
  245. bool Decoder::quantization_params()
  246. {
  247. auto base_q_idx = m_bit_stream->read_byte();
  248. auto delta_q_y_dc = read_delta_q();
  249. auto delta_q_uv_dc = read_delta_q();
  250. auto delta_q_uv_ac = read_delta_q();
  251. m_lossless = base_q_idx == 0 && delta_q_y_dc == 0 && delta_q_uv_dc == 0 && delta_q_uv_ac == 0;
  252. return true;
  253. }
  254. i8 Decoder::read_delta_q()
  255. {
  256. if (m_bit_stream->read_bit())
  257. return m_bit_stream->read_s(4);
  258. return 0;
  259. }
  260. bool Decoder::segmentation_params()
  261. {
  262. auto segmentation_enabled = m_bit_stream->read_bit();
  263. if (!segmentation_enabled)
  264. return true;
  265. auto segmentation_update_map = m_bit_stream->read_bit();
  266. if (segmentation_update_map) {
  267. for (auto i = 0; i < 7; i++) {
  268. m_segmentation_tree_probs[i] = read_prob();
  269. }
  270. auto segmentation_temporal_update = m_bit_stream->read_bit();
  271. for (auto i = 0; i < 3; i++) {
  272. m_segmentation_pred_prob[i] = segmentation_temporal_update ? read_prob() : 255;
  273. }
  274. }
  275. if (!m_bit_stream->read_bit())
  276. return true;
  277. m_segmentation_abs_or_delta_update = m_bit_stream->read_bit();
  278. for (auto i = 0; i < MAX_SEGMENTS; i++) {
  279. for (auto j = 0; j < SEG_LVL_MAX; j++) {
  280. auto feature_value = 0;
  281. auto feature_enabled = m_bit_stream->read_bit();
  282. m_feature_enabled[i][j] = feature_enabled;
  283. if (feature_enabled) {
  284. auto bits_to_read = segmentation_feature_bits[j];
  285. feature_value = m_bit_stream->read_f(bits_to_read);
  286. if (segmentation_feature_signed[j]) {
  287. if (m_bit_stream->read_bit())
  288. feature_value = -feature_value;
  289. }
  290. }
  291. m_feature_data[i][j] = feature_value;
  292. }
  293. }
  294. return true;
  295. }
  296. u8 Decoder::read_prob()
  297. {
  298. if (m_bit_stream->read_bit())
  299. return m_bit_stream->read_byte();
  300. return 255;
  301. }
  302. bool Decoder::tile_info()
  303. {
  304. auto min_log2_tile_cols = calc_min_log2_tile_cols();
  305. auto max_log2_tile_cols = calc_max_log2_tile_cols();
  306. m_tile_cols_log2 = min_log2_tile_cols;
  307. while (m_tile_cols_log2 < max_log2_tile_cols) {
  308. if (m_bit_stream->read_bit())
  309. m_tile_cols_log2++;
  310. else
  311. break;
  312. }
  313. m_tile_rows_log2 = m_bit_stream->read_bit();
  314. if (m_tile_rows_log2) {
  315. m_tile_rows_log2 += m_bit_stream->read_bit();
  316. }
  317. return true;
  318. }
  319. u16 Decoder::calc_min_log2_tile_cols()
  320. {
  321. auto min_log_2 = 0;
  322. while ((MAX_TILE_WIDTH_B64 << min_log_2) < m_sb64_cols)
  323. min_log_2++;
  324. return min_log_2;
  325. }
  326. u16 Decoder::calc_max_log2_tile_cols()
  327. {
  328. u16 max_log_2 = 1;
  329. while ((m_sb64_cols >> max_log_2) >= MIN_TILE_WIDTH_B64)
  330. max_log_2++;
  331. return max_log_2 - 1;
  332. }
  333. bool Decoder::setup_past_independence()
  334. {
  335. for (auto i = 0; i < 8; i++) {
  336. for (auto j = 0; j < 4; j++) {
  337. m_feature_data[i][j] = 0;
  338. m_feature_enabled[i][j] = false;
  339. }
  340. }
  341. m_segmentation_abs_or_delta_update = false;
  342. for (auto row = 0; row < m_mi_rows; row++) {
  343. for (auto col = 0; col < m_mi_cols; col++) {
  344. // TODO: m_prev_segment_ids[row][col] = 0;
  345. }
  346. }
  347. m_loop_filter_delta_enabled = true;
  348. m_loop_filter_ref_deltas[IntraFrame] = 1;
  349. m_loop_filter_ref_deltas[LastFrame] = 0;
  350. m_loop_filter_ref_deltas[GoldenFrame] = -1;
  351. m_loop_filter_ref_deltas[AltRefFrame] = -1;
  352. for (auto i = 0; i < 2; i++) {
  353. m_loop_filter_mode_deltas[i] = 0;
  354. }
  355. m_probability_tables->reset_probs();
  356. return true;
  357. }
  358. bool Decoder::trailing_bits()
  359. {
  360. while (m_bit_stream->get_position() & 7u)
  361. RESERVED_ZERO;
  362. return true;
  363. }
  364. void Decoder::dump_info()
  365. {
  366. dbgln("Frame dimensions: {}x{}", m_frame_width, m_frame_height);
  367. dbgln("Render dimensions: {}x{}", m_render_width, m_render_height);
  368. dbgln("Bit depth: {}", m_bit_depth);
  369. dbgln("Interpolation filter: {}", (u8)m_interpolation_filter);
  370. }
  371. }