mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 15:28:11 +00:00
LibVideo/VP9: Move segmentation parameters to FrameContext
Note that some of the previous segmentation feature settings must be preserved when a frame is decoded that doesn't use segmentation. This change also allowed a few functions in Decoder to be made static.
This commit is contained in:
Zaggy1024
Andreas Kling
parent
d82dc14bd9
commit
fedbc12c4d
7 changed files with 74 additions and 64 deletions
|
|
@ -254,6 +254,11 @@ struct ColorConfig {
|
|||
bool subsampling_y { true };
|
||||
};
|
||||
|
||||
struct SegmentFeature {
|
||||
bool enabled { false };
|
||||
u8 value { 0 };
|
||||
};
|
||||
|
||||
struct FrameContext {
|
||||
public:
|
||||
FrameContext(Vector2D<FrameBlockContext>& contexts)
|
||||
|
|
@ -330,6 +335,15 @@ public:
|
|||
return base_quantizer_index == 0 && y_dc_quantizer_index_delta == 0 && uv_dc_quantizer_index_delta == 0 && uv_ac_quantizer_index_delta == 0;
|
||||
}
|
||||
|
||||
bool segmentation_enabled { false };
|
||||
// Note: We can use Optional<Array<...>> for these tree probabilities, but unfortunately it seems to have measurable performance overhead.
|
||||
bool use_full_segment_id_tree { false };
|
||||
Array<u8, 7> full_segment_id_tree_probabilities;
|
||||
bool use_predicted_segment_id_tree { false };
|
||||
Array<u8, 3> predicted_segment_id_tree_probabilities;
|
||||
bool should_use_absolute_segment_base_quantizer { false };
|
||||
Array<Array<SegmentFeature, SEG_LVL_MAX>, MAX_SEGMENTS> segmentation_features;
|
||||
|
||||
u16 header_size_in_bytes { 0 };
|
||||
|
||||
TXMode transform_mode;
|
||||
|
|
|
|||
|
|
@ -993,11 +993,11 @@ DecoderErrorOr<void> Decoder::predict_inter(u8 plane, BlockContext const& block_
|
|||
return {};
|
||||
}
|
||||
|
||||
u16 Decoder::dc_q(u8 bit_depth, u8 b)
|
||||
inline u16 dc_q(u8 bit_depth, u8 b)
|
||||
{
|
||||
// The function dc_q( b ) is specified as dc_qlookup[ (BitDepth-8) >> 1 ][ Clip3( 0, 255, b ) ] where dc_lookup is
|
||||
// defined as follows:
|
||||
static const u16 dc_qlookup[3][256] = {
|
||||
constexpr u16 dc_qlookup[3][256] = {
|
||||
{ 4, 8, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42, 43, 43, 44, 45, 46, 47, 48, 48, 49, 50, 51, 52, 53, 53, 54, 55, 56, 57, 57, 58, 59, 60, 61, 62, 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 70, 71, 72, 73, 74, 74, 75, 76, 77, 78, 78, 79, 80, 81, 81, 82, 83, 84, 85, 85, 87, 88, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 108, 110, 111, 113, 114, 116, 117, 118, 120, 121, 123, 125, 127, 129, 131, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 161, 164, 166, 169, 172, 174, 177, 180, 182, 185, 187, 190, 192, 195, 199, 202, 205, 208, 211, 214, 217, 220, 223, 226, 230, 233, 237, 240, 243, 247, 250, 253, 257, 261, 265, 269, 272, 276, 280, 284, 288, 292, 296, 300, 304, 309, 313, 317, 322, 326, 330, 335, 340, 344, 349, 354, 359, 364, 369, 374, 379, 384, 389, 395, 400, 406, 411, 417, 423, 429, 435, 441, 447, 454, 461, 467, 475, 482, 489, 497, 505, 513, 522, 530, 539, 549, 559, 569, 579, 590, 602, 614, 626, 640, 654, 668, 684, 700, 717, 736, 755, 775, 796, 819, 843, 869, 896, 925, 955, 988, 1022, 1058, 1098, 1139, 1184, 1232, 1282, 1336 },
|
||||
{ 4, 9, 10, 13, 15, 17, 20, 22, 25, 28, 31, 34, 37, 40, 43, 47, 50, 53, 57, 60, 64, 68, 71, 75, 78, 82, 86, 90, 93, 97, 101, 105, 109, 113, 116, 120, 124, 128, 132, 136, 140, 143, 147, 151, 155, 159, 163, 166, 170, 174, 178, 182, 185, 189, 193, 197, 200, 204, 208, 212, 215, 219, 223, 226, 230, 233, 237, 241, 244, 248, 251, 255, 259, 262, 266, 269, 273, 276, 280, 283, 287, 290, 293, 297, 300, 304, 307, 310, 314, 317, 321, 324, 327, 331, 334, 337, 343, 350, 356, 362, 369, 375, 381, 387, 394, 400, 406, 412, 418, 424, 430, 436, 442, 448, 454, 460, 466, 472, 478, 484, 490, 499, 507, 516, 525, 533, 542, 550, 559, 567, 576, 584, 592, 601, 609, 617, 625, 634, 644, 655, 666, 676, 687, 698, 708, 718, 729, 739, 749, 759, 770, 782, 795, 807, 819, 831, 844, 856, 868, 880, 891, 906, 920, 933, 947, 961, 975, 988, 1001, 1015, 1030, 1045, 1061, 1076, 1090, 1105, 1120, 1137, 1153, 1170, 1186, 1202, 1218, 1236, 1253, 1271, 1288, 1306, 1323, 1342, 1361, 1379, 1398, 1416, 1436, 1456, 1476, 1496, 1516, 1537, 1559, 1580, 1601, 1624, 1647, 1670, 1692, 1717, 1741, 1766, 1791, 1817, 1844, 1871, 1900, 1929, 1958, 1990, 2021, 2054, 2088, 2123, 2159, 2197, 2236, 2276, 2319, 2363, 2410, 2458, 2508, 2561, 2616, 2675, 2737, 2802, 2871, 2944, 3020, 3102, 3188, 3280, 3375, 3478, 3586, 3702, 3823, 3953, 4089, 4236, 4394, 4559, 4737, 4929, 5130, 5347 },
|
||||
{ 4, 12, 18, 25, 33, 41, 50, 60, 70, 80, 91, 103, 115, 127, 140, 153, 166, 180, 194, 208, 222, 237, 251, 266, 281, 296, 312, 327, 343, 358, 374, 390, 405, 421, 437, 453, 469, 484, 500, 516, 532, 548, 564, 580, 596, 611, 627, 643, 659, 674, 690, 706, 721, 737, 752, 768, 783, 798, 814, 829, 844, 859, 874, 889, 904, 919, 934, 949, 964, 978, 993, 1008, 1022, 1037, 1051, 1065, 1080, 1094, 1108, 1122, 1136, 1151, 1165, 1179, 1192, 1206, 1220, 1234, 1248, 1261, 1275, 1288, 1302, 1315, 1329, 1342, 1368, 1393, 1419, 1444, 1469, 1494, 1519, 1544, 1569, 1594, 1618, 1643, 1668, 1692, 1717, 1741, 1765, 1789, 1814, 1838, 1862, 1885, 1909, 1933, 1957, 1992, 2027, 2061, 2096, 2130, 2165, 2199, 2233, 2267, 2300, 2334, 2367, 2400, 2434, 2467, 2499, 2532, 2575, 2618, 2661, 2704, 2746, 2788, 2830, 2872, 2913, 2954, 2995, 3036, 3076, 3127, 3177, 3226, 3275, 3324, 3373, 3421, 3469, 3517, 3565, 3621, 3677, 3733, 3788, 3843, 3897, 3951, 4005, 4058, 4119, 4181, 4241, 4301, 4361, 4420, 4479, 4546, 4612, 4677, 4742, 4807, 4871, 4942, 5013, 5083, 5153, 5222, 5291, 5367, 5442, 5517, 5591, 5665, 5745, 5825, 5905, 5984, 6063, 6149, 6234, 6319, 6404, 6495, 6587, 6678, 6769, 6867, 6966, 7064, 7163, 7269, 7376, 7483, 7599, 7715, 7832, 7958, 8085, 8214, 8352, 8492, 8635, 8788, 8945, 9104, 9275, 9450, 9639, 9832, 10031, 10245, 10465, 10702, 10946, 11210, 11482, 11776, 12081, 12409, 12750, 13118, 13501, 13913, 14343, 14807, 15290, 15812, 16356, 16943, 17575, 18237, 18949, 19718, 20521, 21387 }
|
||||
|
|
@ -1006,11 +1006,11 @@ u16 Decoder::dc_q(u8 bit_depth, u8 b)
|
|||
return dc_qlookup[(bit_depth - 8) >> 1][clip_3<u8>(0, 255, b)];
|
||||
}
|
||||
|
||||
u16 Decoder::ac_q(u8 bit_depth, u8 b)
|
||||
inline u16 ac_q(u8 bit_depth, u8 b)
|
||||
{
|
||||
// The function ac_q( b ) is specified as ac_qlookup[ (BitDepth-8) >> 1 ][ Clip3( 0, 255, b ) ] where ac_lookup is
|
||||
// defined as follows:
|
||||
static const u16 ac_qlookup[3][256] = {
|
||||
constexpr u16 ac_qlookup[3][256] = {
|
||||
{ 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 155, 158, 161, 164, 167, 170, 173, 176, 179, 182, 185, 188, 191, 194, 197, 200, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255, 260, 265, 270, 275, 280, 285, 290, 295, 300, 305, 311, 317, 323, 329, 335, 341, 347, 353, 359, 366, 373, 380, 387, 394, 401, 408, 416, 424, 432, 440, 448, 456, 465, 474, 483, 492, 501, 510, 520, 530, 540, 550, 560, 571, 582, 593, 604, 615, 627, 639, 651, 663, 676, 689, 702, 715, 729, 743, 757, 771, 786, 801, 816, 832, 848, 864, 881, 898, 915, 933, 951, 969, 988, 1007, 1026, 1046, 1066, 1087, 1108, 1129, 1151, 1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343, 1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567, 1597, 1628, 1660, 1692, 1725, 1759, 1793, 1828 },
|
||||
{ 4, 9, 11, 13, 16, 18, 21, 24, 27, 30, 33, 37, 40, 44, 48, 51, 55, 59, 63, 67, 71, 75, 79, 83, 88, 92, 96, 100, 105, 109, 114, 118, 122, 127, 131, 136, 140, 145, 149, 154, 158, 163, 168, 172, 177, 181, 186, 190, 195, 199, 204, 208, 213, 217, 222, 226, 231, 235, 240, 244, 249, 253, 258, 262, 267, 271, 275, 280, 284, 289, 293, 297, 302, 306, 311, 315, 319, 324, 328, 332, 337, 341, 345, 349, 354, 358, 362, 367, 371, 375, 379, 384, 388, 392, 396, 401, 409, 417, 425, 433, 441, 449, 458, 466, 474, 482, 490, 498, 506, 514, 523, 531, 539, 547, 555, 563, 571, 579, 588, 596, 604, 616, 628, 640, 652, 664, 676, 688, 700, 713, 725, 737, 749, 761, 773, 785, 797, 809, 825, 841, 857, 873, 889, 905, 922, 938, 954, 970, 986, 1002, 1018, 1038, 1058, 1078, 1098, 1118, 1138, 1158, 1178, 1198, 1218, 1242, 1266, 1290, 1314, 1338, 1362, 1386, 1411, 1435, 1463, 1491, 1519, 1547, 1575, 1603, 1631, 1663, 1695, 1727, 1759, 1791, 1823, 1859, 1895, 1931, 1967, 2003, 2039, 2079, 2119, 2159, 2199, 2239, 2283, 2327, 2371, 2415, 2459, 2507, 2555, 2603, 2651, 2703, 2755, 2807, 2859, 2915, 2971, 3027, 3083, 3143, 3203, 3263, 3327, 3391, 3455, 3523, 3591, 3659, 3731, 3803, 3876, 3952, 4028, 4104, 4184, 4264, 4348, 4432, 4516, 4604, 4692, 4784, 4876, 4972, 5068, 5168, 5268, 5372, 5476, 5584, 5692, 5804, 5916, 6032, 6148, 6268, 6388, 6512, 6640, 6768, 6900, 7036, 7172, 7312 },
|
||||
{ 4, 13, 19, 27, 35, 44, 54, 64, 75, 87, 99, 112, 126, 139, 154, 168, 183, 199, 214, 230, 247, 263, 280, 297, 314, 331, 349, 366, 384, 402, 420, 438, 456, 475, 493, 511, 530, 548, 567, 586, 604, 623, 642, 660, 679, 698, 716, 735, 753, 772, 791, 809, 828, 846, 865, 884, 902, 920, 939, 957, 976, 994, 1012, 1030, 1049, 1067, 1085, 1103, 1121, 1139, 1157, 1175, 1193, 1211, 1229, 1246, 1264, 1282, 1299, 1317, 1335, 1352, 1370, 1387, 1405, 1422, 1440, 1457, 1474, 1491, 1509, 1526, 1543, 1560, 1577, 1595, 1627, 1660, 1693, 1725, 1758, 1791, 1824, 1856, 1889, 1922, 1954, 1987, 2020, 2052, 2085, 2118, 2150, 2183, 2216, 2248, 2281, 2313, 2346, 2378, 2411, 2459, 2508, 2556, 2605, 2653, 2701, 2750, 2798, 2847, 2895, 2943, 2992, 3040, 3088, 3137, 3185, 3234, 3298, 3362, 3426, 3491, 3555, 3619, 3684, 3748, 3812, 3876, 3941, 4005, 4069, 4149, 4230, 4310, 4390, 4470, 4550, 4631, 4711, 4791, 4871, 4967, 5064, 5160, 5256, 5352, 5448, 5544, 5641, 5737, 5849, 5961, 6073, 6185, 6297, 6410, 6522, 6650, 6778, 6906, 7034, 7162, 7290, 7435, 7579, 7723, 7867, 8011, 8155, 8315, 8475, 8635, 8795, 8956, 9132, 9308, 9484, 9660, 9836, 10028, 10220, 10412, 10604, 10812, 11020, 11228, 11437, 11661, 11885, 12109, 12333, 12573, 12813, 13053, 13309, 13565, 13821, 14093, 14365, 14637, 14925, 15213, 15502, 15806, 16110, 16414, 16734, 17054, 17390, 17726, 18062, 18414, 18766, 19134, 19502, 19886, 20270, 20670, 21070, 21486, 21902, 22334, 22766, 23214, 23662, 24126, 24590, 25070, 25551, 26047, 26559, 27071, 27599, 28143, 28687, 29247 }
|
||||
|
|
@ -1023,12 +1023,12 @@ u8 Decoder::get_base_quantizer_index(BlockContext const& block_context)
|
|||
{
|
||||
// The function get_qindex( ) returns the quantizer index for the current block and is specified by the following:
|
||||
// − If seg_feature_active( SEG_LVL_ALT_Q ) is equal to 1 the following ordered steps apply:
|
||||
if (m_parser->seg_feature_active(block_context, SEG_LVL_ALT_Q)) {
|
||||
if (Parser::seg_feature_active(block_context, SEG_LVL_ALT_Q)) {
|
||||
// 1. Set the variable data equal to FeatureData[ segment_id ][ SEG_LVL_ALT_Q ].
|
||||
auto data = m_parser->m_feature_data[block_context.segment_id][SEG_LVL_ALT_Q];
|
||||
auto data = block_context.frame_context.segmentation_features[block_context.segment_id][SEG_LVL_ALT_Q].value;
|
||||
|
||||
// 2. If segmentation_abs_or_delta_update is equal to 0, set data equal to base_q_idx + data
|
||||
if (!m_parser->m_segmentation_abs_or_delta_update) {
|
||||
if (!block_context.frame_context.should_use_absolute_segment_base_quantizer) {
|
||||
data += block_context.frame_context.base_quantizer_index;
|
||||
}
|
||||
|
||||
|
|
@ -1820,7 +1820,7 @@ DecoderErrorOr<void> Decoder::update_reference_frames(FrameContext const& frame_
|
|||
// − show_existing_frame is equal to 0,
|
||||
// − segmentation_enabled is equal to 1,
|
||||
// − segmentation_update_map is equal to 1.
|
||||
bool keep_segment_ids = !frame_context.shows_existing_frame() && m_parser->m_segmentation_enabled && m_parser->m_segmentation_update_map;
|
||||
bool keep_segment_ids = !frame_context.shows_existing_frame() && frame_context.segmentation_enabled && frame_context.use_full_segment_id_tree;
|
||||
frame_context.block_contexts().copy_to(m_parser->m_previous_block_contexts, [keep_segment_ids](FrameBlockContext context) {
|
||||
auto persistent_context = PersistentBlockContext(context);
|
||||
if (!keep_segment_ids)
|
||||
|
|
|
|||
|
|
@ -73,15 +73,12 @@ private:
|
|||
|
||||
/* (8.6) Reconstruction and Dequantization */
|
||||
|
||||
// FIXME: These should be inline or constexpr
|
||||
u16 dc_q(u8 bit_depth, u8 b);
|
||||
u16 ac_q(u8 bit_depth, u8 b);
|
||||
// Returns the quantizer index for the current block
|
||||
u8 get_base_quantizer_index(BlockContext const&);
|
||||
static u8 get_base_quantizer_index(BlockContext const&);
|
||||
// Returns the quantizer value for the dc coefficient for a particular plane
|
||||
u16 get_dc_quantizer(BlockContext const&, u8 plane);
|
||||
static u16 get_dc_quantizer(BlockContext const&, u8 plane);
|
||||
// Returns the quantizer value for the ac coefficient for a particular plane
|
||||
u16 get_ac_quantizer(BlockContext const&, u8 plane);
|
||||
static u16 get_ac_quantizer(BlockContext const&, u8 plane);
|
||||
|
||||
// (8.6.2) Reconstruct process
|
||||
DecoderErrorOr<void> reconstruct(u8 plane, BlockContext const&, u32 transform_block_x, u32 transform_block_y, TXSize transform_block_size);
|
||||
|
|
|
|||
|
|
@ -110,6 +110,11 @@ DecoderErrorOr<FrameContext> Parser::parse_frame(ReadonlyBytes frame_data)
|
|||
m_previous_loop_filter_ref_deltas = frame_context.loop_filter_reference_deltas;
|
||||
m_previous_loop_filter_mode_deltas = frame_context.loop_filter_mode_deltas;
|
||||
|
||||
if (frame_context.segmentation_enabled) {
|
||||
m_previous_should_use_absolute_segment_base_quantizer = frame_context.should_use_absolute_segment_base_quantizer;
|
||||
m_previous_segmentation_features = frame_context.segmentation_features;
|
||||
}
|
||||
|
||||
return frame_context;
|
||||
}
|
||||
|
||||
|
|
@ -265,7 +270,7 @@ DecoderErrorOr<FrameContext> Parser::uncompressed_header()
|
|||
|
||||
TRY(loop_filter_params(frame_context));
|
||||
TRY(quantization_params(frame_context));
|
||||
TRY(segmentation_params());
|
||||
TRY(segmentation_params(frame_context));
|
||||
TRY(parse_tile_counts(frame_context));
|
||||
|
||||
frame_context.header_size_in_bytes = TRY_READ(m_bit_stream->read_f16());
|
||||
|
|
@ -437,19 +442,25 @@ DecoderErrorOr<i8> Parser::read_delta_q()
|
|||
return 0;
|
||||
}
|
||||
|
||||
DecoderErrorOr<void> Parser::segmentation_params()
|
||||
DecoderErrorOr<void> Parser::segmentation_params(FrameContext& frame_context)
|
||||
{
|
||||
m_segmentation_enabled = TRY_READ(m_bit_stream->read_bit());
|
||||
if (!m_segmentation_enabled)
|
||||
frame_context.segmentation_enabled = TRY_READ(m_bit_stream->read_bit());
|
||||
if (!frame_context.segmentation_enabled)
|
||||
return {};
|
||||
|
||||
m_segmentation_update_map = TRY_READ(m_bit_stream->read_bit());
|
||||
if (m_segmentation_update_map) {
|
||||
for (auto& segmentation_tree_prob : m_segmentation_tree_probs)
|
||||
frame_context.should_use_absolute_segment_base_quantizer = m_previous_should_use_absolute_segment_base_quantizer;
|
||||
frame_context.segmentation_features = m_previous_segmentation_features;
|
||||
|
||||
if (TRY_READ(m_bit_stream->read_bit())) {
|
||||
frame_context.use_full_segment_id_tree = true;
|
||||
for (auto& segmentation_tree_prob : frame_context.full_segment_id_tree_probabilities)
|
||||
segmentation_tree_prob = TRY(read_prob());
|
||||
m_segmentation_temporal_update = TRY_READ(m_bit_stream->read_bit());
|
||||
for (auto& segmentation_pred_prob : m_segmentation_pred_prob)
|
||||
segmentation_pred_prob = m_segmentation_temporal_update ? TRY(read_prob()) : 255;
|
||||
|
||||
if (TRY_READ(m_bit_stream->read_bit())) {
|
||||
frame_context.use_predicted_segment_id_tree = true;
|
||||
for (auto& segmentation_pred_prob : frame_context.predicted_segment_id_tree_probabilities)
|
||||
segmentation_pred_prob = TRY(read_prob());
|
||||
}
|
||||
}
|
||||
|
||||
auto segmentation_update_data = (TRY_READ(m_bit_stream->read_bit()));
|
||||
|
|
@ -457,21 +468,19 @@ DecoderErrorOr<void> Parser::segmentation_params()
|
|||
if (!segmentation_update_data)
|
||||
return {};
|
||||
|
||||
m_segmentation_abs_or_delta_update = TRY_READ(m_bit_stream->read_bit());
|
||||
frame_context.should_use_absolute_segment_base_quantizer = TRY_READ(m_bit_stream->read_bit());
|
||||
for (auto i = 0; i < MAX_SEGMENTS; i++) {
|
||||
for (auto j = 0; j < SEG_LVL_MAX; j++) {
|
||||
auto feature_value = 0;
|
||||
auto feature_enabled = TRY_READ(m_bit_stream->read_bit());
|
||||
m_feature_enabled[i][j] = feature_enabled;
|
||||
if (feature_enabled) {
|
||||
auto& feature = frame_context.segmentation_features[i][j];
|
||||
feature.enabled = TRY_READ(m_bit_stream->read_bit());
|
||||
if (feature.enabled) {
|
||||
auto bits_to_read = segmentation_feature_bits[j];
|
||||
feature_value = TRY_READ(m_bit_stream->read_bits(bits_to_read));
|
||||
feature.value = TRY_READ(m_bit_stream->read_bits(bits_to_read));
|
||||
if (segmentation_feature_signed[j]) {
|
||||
if (TRY_READ(m_bit_stream->read_bit()))
|
||||
feature_value = -feature_value;
|
||||
feature.value = -feature.value;
|
||||
}
|
||||
}
|
||||
m_feature_data[i][j] = feature_value;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -524,19 +533,15 @@ DecoderErrorOr<void> Parser::parse_tile_counts(FrameContext& frame_context)
|
|||
|
||||
void Parser::setup_past_independence()
|
||||
{
|
||||
for (auto i = 0; i < 8; i++) {
|
||||
for (auto j = 0; j < 4; j++) {
|
||||
m_feature_data[i][j] = 0;
|
||||
m_feature_enabled[i][j] = false;
|
||||
}
|
||||
}
|
||||
m_previous_block_contexts.reset();
|
||||
m_segmentation_abs_or_delta_update = false;
|
||||
m_previous_loop_filter_ref_deltas[IntraFrame] = 1;
|
||||
m_previous_loop_filter_ref_deltas[LastFrame] = 0;
|
||||
m_previous_loop_filter_ref_deltas[GoldenFrame] = -1;
|
||||
m_previous_loop_filter_ref_deltas[AltRefFrame] = -1;
|
||||
m_previous_loop_filter_mode_deltas.fill(0);
|
||||
m_previous_should_use_absolute_segment_base_quantizer = false;
|
||||
for (auto& segment_levels : m_previous_segmentation_features)
|
||||
segment_levels.fill({ false, 0 });
|
||||
m_probability_tables->reset_probs();
|
||||
}
|
||||
|
||||
|
|
@ -1026,8 +1031,8 @@ DecoderErrorOr<void> Parser::intra_frame_mode_info(BlockContext& block_context,
|
|||
|
||||
DecoderErrorOr<void> Parser::set_intra_segment_id(BlockContext& block_context)
|
||||
{
|
||||
if (m_segmentation_enabled && m_segmentation_update_map)
|
||||
block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs));
|
||||
if (block_context.frame_context.segmentation_enabled && block_context.frame_context.use_full_segment_id_tree)
|
||||
block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, block_context.frame_context.full_segment_id_tree_probabilities));
|
||||
else
|
||||
block_context.segment_id = 0;
|
||||
return {};
|
||||
|
|
@ -1042,7 +1047,7 @@ DecoderErrorOr<bool> Parser::read_should_skip_residuals(BlockContext& block_cont
|
|||
|
||||
bool Parser::seg_feature_active(BlockContext const& block_context, u8 feature)
|
||||
{
|
||||
return m_segmentation_enabled && m_feature_enabled[block_context.segment_id][feature];
|
||||
return block_context.frame_context.segmentation_features[block_context.segment_id][feature].enabled;
|
||||
}
|
||||
|
||||
DecoderErrorOr<TXSize> Parser::read_tx_size(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context, bool allow_select)
|
||||
|
|
@ -1069,25 +1074,25 @@ DecoderErrorOr<void> Parser::inter_frame_mode_info(BlockContext& block_context,
|
|||
|
||||
DecoderErrorOr<void> Parser::set_inter_segment_id(BlockContext& block_context)
|
||||
{
|
||||
if (!m_segmentation_enabled) {
|
||||
if (!block_context.frame_context.segmentation_enabled) {
|
||||
block_context.segment_id = 0;
|
||||
return {};
|
||||
}
|
||||
auto predicted_segment_id = get_segment_id(block_context);
|
||||
if (!m_segmentation_update_map) {
|
||||
if (!block_context.frame_context.use_full_segment_id_tree) {
|
||||
block_context.segment_id = predicted_segment_id;
|
||||
return {};
|
||||
}
|
||||
if (!m_segmentation_temporal_update) {
|
||||
block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs));
|
||||
if (!block_context.frame_context.use_predicted_segment_id_tree) {
|
||||
block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, block_context.frame_context.full_segment_id_tree_probabilities));
|
||||
return {};
|
||||
}
|
||||
|
||||
auto seg_id_predicted = TRY_READ(TreeParser::parse_segment_id_predicted(*m_bit_stream, m_segmentation_pred_prob, m_left_seg_pred_context[block_context.row], m_above_seg_pred_context[block_context.column]));
|
||||
auto seg_id_predicted = TRY_READ(TreeParser::parse_segment_id_predicted(*m_bit_stream, block_context.frame_context.predicted_segment_id_tree_probabilities, m_left_seg_pred_context[block_context.row], m_above_seg_pred_context[block_context.column]));
|
||||
if (seg_id_predicted)
|
||||
block_context.segment_id = predicted_segment_id;
|
||||
else
|
||||
block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, m_segmentation_tree_probs));
|
||||
block_context.segment_id = TRY_READ(TreeParser::parse_segment_id(*m_bit_stream, block_context.frame_context.full_segment_id_tree_probabilities));
|
||||
|
||||
for (size_t i = 0; i < num_8x8_blocks_wide_lookup[block_context.size]; i++) {
|
||||
auto index = block_context.column + i;
|
||||
|
|
@ -1122,7 +1127,7 @@ u8 Parser::get_segment_id(BlockContext const& block_context)
|
|||
DecoderErrorOr<bool> Parser::read_is_inter(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context)
|
||||
{
|
||||
if (seg_feature_active(block_context, SEG_LVL_REF_FRAME))
|
||||
return m_feature_data[block_context.segment_id][SEG_LVL_REF_FRAME] != IntraFrame;
|
||||
return block_context.frame_context.segmentation_features[block_context.segment_id][SEG_LVL_REF_FRAME].value != IntraFrame;
|
||||
return TRY_READ(TreeParser::parse_block_is_inter_predicted(*m_bit_stream, *m_probability_tables, *m_syntax_element_counter, above_context, left_context));
|
||||
}
|
||||
|
||||
|
|
@ -1205,7 +1210,7 @@ DecoderErrorOr<void> Parser::inter_block_mode_info(BlockContext& block_context,
|
|||
DecoderErrorOr<void> Parser::read_ref_frames(BlockContext& block_context, FrameBlockContext above_context, FrameBlockContext left_context)
|
||||
{
|
||||
if (seg_feature_active(block_context, SEG_LVL_REF_FRAME)) {
|
||||
block_context.reference_frame_types = { static_cast<ReferenceFrameType>(m_feature_data[block_context.segment_id][SEG_LVL_REF_FRAME]), None };
|
||||
block_context.reference_frame_types = { static_cast<ReferenceFrameType>(block_context.frame_context.segmentation_features[block_context.segment_id][SEG_LVL_REF_FRAME].value), None };
|
||||
return {};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ private:
|
|||
DecoderErrorOr<void> loop_filter_params(FrameContext&);
|
||||
DecoderErrorOr<void> quantization_params(FrameContext&);
|
||||
DecoderErrorOr<i8> read_delta_q();
|
||||
DecoderErrorOr<void> segmentation_params();
|
||||
DecoderErrorOr<void> segmentation_params(FrameContext&);
|
||||
DecoderErrorOr<u8> read_prob();
|
||||
DecoderErrorOr<void> parse_tile_counts(FrameContext&);
|
||||
void setup_past_independence();
|
||||
|
|
@ -104,7 +104,7 @@ private:
|
|||
DecoderErrorOr<void> intra_frame_mode_info(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context);
|
||||
DecoderErrorOr<void> set_intra_segment_id(BlockContext&);
|
||||
DecoderErrorOr<bool> read_should_skip_residuals(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context);
|
||||
bool seg_feature_active(BlockContext const&, u8 feature);
|
||||
static bool seg_feature_active(BlockContext const&, u8 feature);
|
||||
DecoderErrorOr<TXSize> read_tx_size(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context, bool allow_select);
|
||||
DecoderErrorOr<void> inter_frame_mode_info(BlockContext&, FrameBlockContext above_context, FrameBlockContext left_context);
|
||||
DecoderErrorOr<void> set_inter_segment_id(BlockContext&);
|
||||
|
|
@ -139,14 +139,8 @@ private:
|
|||
FrameType m_previous_frame_type { FrameType::KeyFrame };
|
||||
Array<i8, MAX_REF_FRAMES> m_previous_loop_filter_ref_deltas;
|
||||
Array<i8, 2> m_previous_loop_filter_mode_deltas;
|
||||
u8 m_segmentation_tree_probs[7];
|
||||
u8 m_segmentation_pred_prob[3];
|
||||
bool m_feature_enabled[8][4];
|
||||
u8 m_feature_data[8][4];
|
||||
bool m_segmentation_enabled { false };
|
||||
bool m_segmentation_update_map { false };
|
||||
bool m_segmentation_temporal_update { false };
|
||||
bool m_segmentation_abs_or_delta_update { false };
|
||||
bool m_previous_should_use_absolute_segment_base_quantizer;
|
||||
Array<Array<SegmentFeature, SEG_LVL_MAX>, MAX_SEGMENTS> m_previous_segmentation_features;
|
||||
|
||||
// FIXME: Move above and left contexts to structs
|
||||
Array<Vector<bool>, 3> m_above_nonzero_context;
|
||||
|
|
|
|||
|
|
@ -163,14 +163,14 @@ ErrorOr<PredictionMode> TreeParser::parse_uv_mode(BitStream& bit_stream, Probabi
|
|||
return value;
|
||||
}
|
||||
|
||||
ErrorOr<u8> TreeParser::parse_segment_id(BitStream& bit_stream, u8 const probabilities[7])
|
||||
ErrorOr<u8> TreeParser::parse_segment_id(BitStream& bit_stream, Array<u8, 7> const& probabilities)
|
||||
{
|
||||
auto value = TRY(parse_tree<u8>(bit_stream, { segment_tree }, [&](u8 node) { return probabilities[node]; }));
|
||||
// Segment ID is not counted.
|
||||
return value;
|
||||
}
|
||||
|
||||
ErrorOr<bool> TreeParser::parse_segment_id_predicted(BitStream& bit_stream, u8 const probabilities[3], u8 above_seg_pred_context, u8 left_seg_pred_context)
|
||||
ErrorOr<bool> TreeParser::parse_segment_id_predicted(BitStream& bit_stream, Array<u8, 3> const& probabilities, u8 above_seg_pred_context, u8 left_seg_pred_context)
|
||||
{
|
||||
auto context = left_seg_pred_context + above_seg_pred_context;
|
||||
auto value = TRY(parse_tree<bool>(bit_stream, { binary_tree }, [&](u8) { return probabilities[context]; }));
|
||||
|
|
|
|||
|
|
@ -54,8 +54,8 @@ public:
|
|||
static ErrorOr<PredictionMode> parse_intra_mode(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, BlockSubsize mi_size);
|
||||
static ErrorOr<PredictionMode> parse_sub_intra_mode(BitStream&, ProbabilityTables const&, SyntaxElementCounter&);
|
||||
static ErrorOr<PredictionMode> parse_uv_mode(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, PredictionMode y_mode);
|
||||
static ErrorOr<u8> parse_segment_id(BitStream&, u8 const probabilities[7]);
|
||||
static ErrorOr<bool> parse_segment_id_predicted(BitStream&, u8 const probabilities[3], u8 above_seg_pred_context, u8 left_seg_pred_context);
|
||||
static ErrorOr<u8> parse_segment_id(BitStream&, Array<u8, 7> const& probabilities);
|
||||
static ErrorOr<bool> parse_segment_id_predicted(BitStream&, Array<u8, 3> const& probabilities, u8 above_seg_pred_context, u8 left_seg_pred_context);
|
||||
static ErrorOr<PredictionMode> parse_inter_mode(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, u8 mode_context_for_ref_frame_0);
|
||||
static ErrorOr<InterpolationFilter> parse_interpolation_filter(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, FrameBlockContext above, FrameBlockContext left);
|
||||
static ErrorOr<bool> parse_skip(BitStream&, ProbabilityTables const&, SyntaxElementCounter&, FrameBlockContext above, FrameBlockContext left);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue