1 /*
2 * Copyright (c) 2015-2021, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_vebox_g11_X.cpp
24 //! \brief Constructs vebox commands on Gen11-based platforms
25 //! \details Each client facing function both creates a HW command and adds
26 //! that command to a command or batch buffer.
27 //!
28
29 #include "mhw_vebox_g11_X.h"
30 #include "mos_solo_generic.h"
31 #include "mos_util_user_interface.h"
32 #include "hal_oca_interface.h"
33
34
35 // H2S Manual Mode Coef
36 static const uint16_t g_Hdr_ColorCorrect_EOTF_SMPTE_ST2084_Input_g11[HDR_OETF_1DLUT_POINT_NUMBER] =
37 {
38 0, 257, 514, 771, 1028, 1285, 1542, 1799, 2056, 2313, 2570, 2827, 3084, 3341, 3598, 3855,
39 4112, 4369, 4626, 4883, 5140, 5397, 5654, 5911, 6168, 6425, 6682, 6939, 7196, 7453, 7710, 7967,
40 8224, 8481, 8738, 8995, 9252, 9509, 9766, 10023, 10280, 10537, 10794, 11051, 11308, 11565, 11822, 12079,
41 12336, 12593, 12850, 13107, 13364, 13621, 13878, 14135, 14392, 14649, 14906, 15163, 15420, 15677, 15934, 16191,
42 16448, 16705, 16962, 17219, 17476, 17733, 17990, 18247, 18504, 18761, 19018, 19275, 19532, 19789, 20046, 20303,
43 20560, 20817, 21074, 21331, 21588, 21845, 22102, 22359, 22616, 22873, 23130, 23387, 23644, 23901, 24158, 24415,
44 24672, 24929, 25186, 25443, 25700, 25957, 26214, 26471, 26728, 26985, 27242, 27499, 27756, 28013, 28270, 28527,
45 28784, 29041, 29298, 29555, 29812, 30069, 30326, 30583, 30840, 31097, 31354, 31611, 31868, 32125, 32382, 32639,
46 32896, 33153, 33410, 33667, 33924, 34181, 34438, 34695, 34952, 35209, 35466, 35723, 35980, 36237, 36494, 36751,
47 37008, 37265, 37522, 37779, 38036, 38293, 38550, 38807, 39064, 39321, 39578, 39835, 40092, 40349, 40606, 40863,
48 41120, 41377, 41634, 41891, 42148, 42405, 42662, 42919, 43176, 43433, 43690, 43947, 44204, 44461, 44718, 44975,
49 45232, 45489, 45746, 46003, 46260, 46517, 46774, 47031, 47288, 47545, 47802, 48059, 48316, 48573, 48830, 49087,
50 49344, 49601, 49858, 50115, 50372, 50629, 50886, 51143, 51400, 51657, 51914, 52171, 52428, 52685, 52942, 53199,
51 53456, 53713, 53970, 54227, 54484, 54741, 54998, 55255, 55512, 55769, 56026, 56283, 56540, 56797, 57054, 57311,
52 57568, 57825, 58082, 58339, 58596, 58853, 59110, 59367, 59624, 59881, 60138, 60395, 60652, 60909, 61166, 61423,
53 61680, 61937, 62194, 62451, 62708, 62965, 63222, 63479, 63736, 63993, 64250, 64507, 64764, 65021, 65278, 65535
54 };
55
56 static const uint16_t g_Hdr_ColorCorrect_EOTF_SMPTE_ST2084_Output_g11[HDR_OETF_1DLUT_POINT_NUMBER] =
57 {
58 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
59 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4,
60 4, 4, 5, 5, 5, 6, 6, 7, 7, 8, 9, 9, 10, 11, 11, 12,
61 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 26, 27, 29, 31, 32,
62 34, 36, 38, 40, 43, 45, 47, 50, 52, 55, 58, 61, 64, 67, 71, 74,
63 78, 82, 86, 90, 95, 99, 104, 109, 114, 119, 125, 131, 137, 143, 150, 157,
64 164, 171, 179, 187, 195, 204, 213, 222, 232, 242, 252, 263, 274, 286, 298, 311,
65 324, 338, 352, 367, 382, 398, 414, 431, 449, 467, 486, 506, 527, 548, 570, 593,
66 617, 641, 667, 693, 721, 749, 779, 809, 841, 874, 908, 944, 980, 1018, 1058, 1099,
67 1141, 1185, 1231, 1278, 1327, 1377, 1430, 1484, 1541, 1599, 1660, 1722, 1787, 1855, 1925, 1997,
68 2072, 2150, 2230, 2314, 2400, 2490, 2583, 2679, 2778, 2882, 2989, 3099, 3214, 3333, 3457, 3584,
69 3717, 3854, 3996, 4143, 4296, 4454, 4618, 4787, 4963, 5146, 5335, 5530, 5733, 5943, 6161, 6387,
70 6621, 6863, 7115, 7375, 7645, 7925, 8215, 8515, 8827, 9150, 9485, 9832, 10192, 10565, 10952, 11353,
71 11769, 12200, 12647, 13110, 13591, 14089, 14606, 15142, 15698, 16275, 16873, 17494, 18138, 18805, 19498, 20217,
72 20963, 21736, 22539, 23372, 24237, 25134, 26066, 27032, 28036, 29077, 30158, 31281, 32446, 33656, 34912, 36217,
73 37572, 38979, 40441, 41959, 43536, 45174, 46876, 48645, 50482, 52392, 54376, 56438, 58582, 60810, 63127, 65535
74 };
75
76 static const uint16_t g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[HDR_OETF_1DLUT_POINT_NUMBER] =
77 {
78 0, 257, 514, 771, 1028, 1285, 1542, 1799, 2056, 2313, 2570, 2827, 3084, 3341, 3598, 3855,
79 4112, 4369, 4626, 4883, 5140, 5397, 5654, 5911, 6168, 6425, 6682, 6939, 7196, 7453, 7710, 7967,
80 8224, 8481, 8738, 8995, 9252, 9509, 9766, 10023, 10280, 10537, 10794, 11051, 11308, 11565, 11822, 12079,
81 12336, 12593, 12850, 13107, 13364, 13621, 13878, 14135, 14392, 14649, 14906, 15163, 15420, 15677, 15934, 16191,
82 16448, 16705, 16962, 17219, 17476, 17733, 17990, 18247, 18504, 18761, 19018, 19275, 19532, 19789, 20046, 20303,
83 20560, 20817, 21074, 21331, 21588, 21845, 22102, 22359, 22616, 22873, 23130, 23387, 23644, 23901, 24158, 24415,
84 24672, 24929, 25186, 25443, 25700, 25957, 26214, 26471, 26728, 26985, 27242, 27499, 27756, 28013, 28270, 28527,
85 28784, 29041, 29298, 29555, 29812, 30069, 30326, 30583, 30840, 31097, 31354, 31611, 31868, 32125, 32382, 32639,
86 32896, 33153, 33410, 33667, 33924, 34181, 34438, 34695, 34952, 35209, 35466, 35723, 35980, 36237, 36494, 36751,
87 37008, 37265, 37522, 37779, 38036, 38293, 38550, 38807, 39064, 39321, 39578, 39835, 40092, 40349, 40606, 40863,
88 41120, 41377, 41634, 41891, 42148, 42405, 42662, 42919, 43176, 43433, 43690, 43947, 44204, 44461, 44718, 44975,
89 45232, 45489, 45746, 46003, 46260, 46517, 46774, 47031, 47288, 47545, 47802, 48059, 48316, 48573, 48830, 49087,
90 49344, 49601, 49858, 50115, 50372, 50629, 50886, 51143, 51400, 51657, 51914, 52171, 52428, 52685, 52942, 53199,
91 53456, 53713, 53970, 54227, 54484, 54741, 54998, 55255, 55512, 55769, 56026, 56283, 56540, 56797, 57054, 57311,
92 57568, 57825, 58082, 58339, 58596, 58853, 59110, 59367, 59624, 59881, 60138, 60395, 60652, 60909, 61166, 61423,
93 61680, 61937, 62194, 62451, 62708, 62965, 63222, 63479, 63736, 63993, 64250, 64507, 64764, 65021, 65278, 65535
94 };
95
96 static const uint16_t g_Hdr_ColorCorrect_OETF_Rec709_Output_g11[HDR_OETF_1DLUT_POINT_NUMBER] =
97 {
98 0, 1157, 2313, 3469, 4626, 5788, 6838, 7795, 8680, 9505, 10282, 11017, 11716, 12383, 13023, 13639,
99 14232, 14805, 15359, 15898, 16420, 16929, 17424, 17907, 18379, 18840, 19291, 19733, 20165, 20589, 21006, 21414,
100 21816, 22211, 22599, 22981, 23357, 23727, 24092, 24451, 24806, 25155, 25500, 25841, 26177, 26509, 26837, 27161,
101 27481, 27798, 28111, 28421, 28727, 29030, 29330, 29627, 29921, 30213, 30501, 30786, 31069, 31350, 31628, 31903,
102 32176, 32447, 32715, 32982, 33246, 33507, 33767, 34025, 34281, 34535, 34787, 35037, 35285, 35531, 35776, 36019,
103 36260, 36500, 36738, 36974, 37209, 37443, 37674, 37905, 38134, 38361, 38587, 38812, 39035, 39257, 39478, 39697,
104 39915, 40132, 40348, 40562, 40776, 40988, 41199, 41409, 41617, 41825, 42031, 42237, 42441, 42645, 42847, 43048,
105 43249, 43448, 43646, 43844, 44040, 44236, 44430, 44624, 44817, 45009, 45200, 45390, 45580, 45768, 45956, 46143,
106 46329, 46514, 46699, 46882, 47065, 47248, 47429, 47610, 47790, 47969, 48147, 48325, 48502, 48679, 48854, 49029,
107 49204, 49378, 49551, 49723, 49895, 50066, 50236, 50406, 50575, 50744, 50912, 51080, 51246, 51413, 51578, 51743,
108 51908, 52072, 52235, 52398, 52560, 52722, 52883, 53044, 53204, 53364, 53523, 53682, 53840, 53997, 54154, 54311,
109 54467, 54623, 54778, 54932, 55086, 55240, 55393, 55546, 55699, 55850, 56002, 56153, 56303, 56453, 56603, 56752,
110 56901, 57049, 57197, 57345, 57492, 57639, 57785, 57931, 58076, 58221, 58366, 58510, 58654, 58798, 58941, 59083,
111 59226, 59368, 59509, 59651, 59792, 59932, 60072, 60212, 60351, 60490, 60629, 60768, 60906, 61043, 61181, 61318,
112 61454, 61591, 61727, 61862, 61998, 62133, 62267, 62402, 62536, 62669, 62803, 62936, 63069, 63201, 63333, 63465,
113 63597, 63728, 63859, 63990, 64120, 64250, 64380, 64509, 64638, 64767, 64896, 65024, 65152, 65280, 65408, 65535
114 };
115
116 const int32_t g_Vebox_BT2020_Inverse_Pixel_Value_g11[256] =
117 {
118 0x0000, 0x14bc, 0x15a8, 0x1694, 0x1780, 0x1870, 0x195c, 0x1a48, 0x1b34, 0x1c24, 0x1d10, 0x1dfc, 0x1eec, 0x1fd8, 0x20c4, 0x21b0,
119 0x22a0, 0x238c, 0x2478, 0x2568, 0x2654, 0x2740, 0x282c, 0x291c, 0x2a08, 0x2af4, 0x2be0, 0x2cd0, 0x2dbc, 0x2ea8, 0x2f98, 0x3084,
120 0x3170, 0x325c, 0x334c, 0x3438, 0x3524, 0x3614, 0x3700, 0x37ec, 0x38d8, 0x39c8, 0x3ab4, 0x3ba0, 0x3c8c, 0x3d7c, 0x3e68, 0x3f54,
121 0x4044, 0x4130, 0x421c, 0x4308, 0x43f8, 0x44e4, 0x45d0, 0x46c0, 0x47ac, 0x4898, 0x4984, 0x4a74, 0x4b60, 0x4c4c, 0x4d38, 0x4e28,
122 0x4f14, 0x5000, 0x50f0, 0x51dc, 0x52c8, 0x53b4, 0x54a4, 0x5590, 0x567c, 0x576c, 0x5858, 0x5944, 0x5a30, 0x5b20, 0x5c0c, 0x5cf8,
123 0x5de8, 0x5ed4, 0x5fc0, 0x60ac, 0x619c, 0x6288, 0x6374, 0x6460, 0x6550, 0x663c, 0x6728, 0x6818, 0x6904, 0x69f0, 0x6adc, 0x6bcc,
124 0x6cb8, 0x6da4, 0x6e94, 0x6f80, 0x706c, 0x7158, 0x7248, 0x7334, 0x7420, 0x750c, 0x75fc, 0x76e8, 0x77d4, 0x78c4, 0x79b0, 0x7a9c,
125 0x7b88, 0x7c78, 0x7d64, 0x7e50, 0x7f40, 0x802c, 0x8118, 0x8204, 0x82f4, 0x83e0, 0x84cc, 0x85b8, 0x86a8, 0x8794, 0x8880, 0x8970,
126 0x8a5c, 0x8b48, 0x8c34, 0x8d24, 0x8e10, 0x8efc, 0x8fec, 0x90d8, 0x91c4, 0x92b0, 0x93a0, 0x948c, 0x9578, 0x9664, 0x9754, 0x9840,
127 0x992c, 0x9a1c, 0x9b08, 0x9bf4, 0x9ce0, 0x9dd0, 0x9ebc, 0x9fa8, 0xa098, 0xa184, 0xa270, 0xa35c, 0xa44c, 0xa538, 0xa624, 0xa714,
128 0xa800, 0xa8ec, 0xa9d8, 0xaac8, 0xabb4, 0xaca0, 0xad8c, 0xae7c, 0xaf68, 0xb054, 0xb144, 0xb230, 0xb31c, 0xb408, 0xb4f8, 0xb5e4,
129 0xb6d0, 0xb7c0, 0xb8ac, 0xb998, 0xba84, 0xbb74, 0xbc60, 0xbd4c, 0xbe38, 0xbf28, 0xc014, 0xc100, 0xc1f0, 0xc2dc, 0xc3c8, 0xc4b4,
130 0xc5a4, 0xc690, 0xc77c, 0xc86c, 0xc958, 0xca44, 0xcb30, 0xcc20, 0xcd0c, 0xcdf8, 0xcee4, 0xcfd4, 0xd0c0, 0xd1ac, 0xd29c, 0xd388,
131 0xd474, 0xd560, 0xd650, 0xd73c, 0xd828, 0xd918, 0xda04, 0xdaf0, 0xdbdc, 0xdccc, 0xddb8, 0xdea4, 0xdf94, 0xe080, 0xe16c, 0xe258,
132 0xe348, 0xe434, 0xe520, 0xe60c, 0xe6fc, 0xe7e8, 0xe8d4, 0xe9c4, 0xeab0, 0xeb9c, 0xec88, 0xed78, 0xee64, 0xef50, 0xf040, 0xf12c,
133 0xf218, 0xf304, 0xf3f4, 0xf4e0, 0xf5cc, 0xf6b8, 0xf7a8, 0xf894, 0xf980, 0xfa70, 0xfb5c, 0xfc48, 0xfd34, 0xfe24, 0xff10, 0xffff
134 };
135
136 const int32_t g_Vebox_BT2020_Forward_Pixel_Value_g11[256] =
137 {
138 0x0000, 0x049c, 0x0598, 0x0694, 0x0794, 0x0890, 0x098c, 0x0a8c, 0x0b88, 0x0c84, 0x0d84, 0x0e80, 0x0f7c, 0x107c, 0x1178, 0x1274,
139 0x1374, 0x1470, 0x156c, 0x166c, 0x1768, 0x1864, 0x1964, 0x1a60, 0x1b5c, 0x1c5c, 0x1d58, 0x1e54, 0x1f54, 0x2050, 0x214c, 0x224c,
140 0x2348, 0x2444, 0x2544, 0x2640, 0x273c, 0x283c, 0x2938, 0x2a34, 0x2b34, 0x2c30, 0x2d30, 0x2e2c, 0x2f28, 0x3028, 0x3124, 0x3220,
141 0x3320, 0x341c, 0x3518, 0x3618, 0x3714, 0x3810, 0x3910, 0x3a0c, 0x3b08, 0x3c08, 0x3d04, 0x3e00, 0x3f00, 0x3ffc, 0x40f8, 0x41f8,
142 0x42f4, 0x43f0, 0x44f0, 0x45ec, 0x46e8, 0x47e8, 0x48e4, 0x49e0, 0x4ae0, 0x4bdc, 0x4cd8, 0x4dd8, 0x4ed4, 0x4fd0, 0x50d0, 0x51cc,
143 0x52c8, 0x53c8, 0x54c4, 0x55c4, 0x56c0, 0x57bc, 0x58bc, 0x59b8, 0x5ab4, 0x5bb4, 0x5cb0, 0x5dac, 0x5eac, 0x5fa8, 0x60a4, 0x61a4,
144 0x62a0, 0x639c, 0x649c, 0x6598, 0x6694, 0x6794, 0x6890, 0x698c, 0x6a8c, 0x6b88, 0x6c84, 0x6d84, 0x6e80, 0x6f7c, 0x707c, 0x7178,
145 0x7274, 0x7374, 0x7470, 0x756c, 0x766c, 0x7768, 0x7864, 0x7964, 0x7a60, 0x7b5c, 0x7c5c, 0x7d58, 0x7e58, 0x7f54, 0x8050, 0x8150,
146 0x824c, 0x8348, 0x8448, 0x8544, 0x8640, 0x8740, 0x883c, 0x8938, 0x8a38, 0x8b34, 0x8c30, 0x8d30, 0x8e2c, 0x8f28, 0x9028, 0x9124,
147 0x9220, 0x9320, 0x941c, 0x9518, 0x9618, 0x9714, 0x9810, 0x9910, 0x9a0c, 0x9b08, 0x9c08, 0x9d04, 0x9e00, 0x9f00, 0x9ffc, 0xa0f8,
148 0xa1f8, 0xa2f4, 0xa3f0, 0xa4f0, 0xa5ec, 0xa6ec, 0xa7e8, 0xa8e4, 0xa9e4, 0xaae0, 0xabdc, 0xacdc, 0xadd8, 0xaed4, 0xafd4, 0xb0d0,
149 0xb1cc, 0xb2cc, 0xb3c8, 0xb4c4, 0xb5c4, 0xb6c0, 0xb7bc, 0xb8bc, 0xb9b8, 0xbab4, 0xbbb4, 0xbcb0, 0xbdac, 0xbeac, 0xbfa8, 0xc0a4,
150 0xc1a4, 0xc2a0, 0xc39c, 0xc49c, 0xc598, 0xc694, 0xc794, 0xc890, 0xc98c, 0xca8c, 0xcb88, 0xcc84, 0xcd84, 0xce80, 0xcf80, 0xd07c,
151 0xd178, 0xd278, 0xd374, 0xd470, 0xd570, 0xd66c, 0xd768, 0xd868, 0xd964, 0xda60, 0xdb60, 0xdc5c, 0xdd58, 0xde58, 0xdf54, 0xe050,
152 0xe150, 0xe24c, 0xe348, 0xe448, 0xe544, 0xe640, 0xe740, 0xe83c, 0xe938, 0xea38, 0xeb34, 0xec30, 0xed30, 0xee2c, 0xef28, 0xf028,
153 0xf124, 0xf220, 0xf320, 0xf41c, 0xf518, 0xf618, 0xf714, 0xf814, 0xf910, 0xfa0c, 0xfb0c, 0xfc08, 0xfd04, 0xfe04, 0xff00, 0xffff
154 };
155 const int32_t g_Vebox_BT2020_Inverse_Gamma_LUT_g11[256] =
156 {
157 0x0000, 0x049c, 0x04cc, 0x0503, 0x053a, 0x0574, 0x05ae, 0x05e9, 0x0626, 0x0665, 0x06a5, 0x06e5, 0x0729, 0x076c, 0x07b1, 0x07f7,
158 0x083f, 0x0888, 0x08d2, 0x091f, 0x096c, 0x09bb, 0x0a0a, 0x0a5d, 0x0aaf, 0x0b03, 0x0b58, 0x0bb0, 0x0c09, 0x0c62, 0x0cbf, 0x0d1b,
159 0x0d79, 0x0dd8, 0x0e3a, 0x0e9c, 0x0f00, 0x0f66, 0x0fcd, 0x1035, 0x109e, 0x110b, 0x1177, 0x11e5, 0x1254, 0x12c6, 0x1339, 0x13ac,
160 0x1423, 0x149a, 0x1512, 0x158c, 0x1609, 0x1685, 0x1704, 0x1785, 0x1806, 0x1889, 0x190d, 0x1995, 0x1a1c, 0x1aa5, 0x1b2f, 0x1bbe,
161 0x1c4b, 0x1cda, 0x1d6d, 0x1dff, 0x1e92, 0x1f27, 0x1fc0, 0x2059, 0x20f2, 0x2190, 0x222d, 0x22cc, 0x236c, 0x2410, 0x24b3, 0x2558,
162 0x2601, 0x26a9, 0x2752, 0x27fe, 0x28ad, 0x295b, 0x2a0b, 0x2abd, 0x2b73, 0x2c28, 0x2cde, 0x2d99, 0x2e53, 0x2f0e, 0x2fcb, 0x308c,
163 0x314c, 0x320e, 0x32d5, 0x339a, 0x3460, 0x3528, 0x35f6, 0x36c1, 0x378e, 0x385d, 0x3931, 0x3a03, 0x3ad7, 0x3bb0, 0x3c87, 0x3d60,
164 0x3e3a, 0x3f1a, 0x3ff8, 0x40d7, 0x41bc, 0x429f, 0x4383, 0x4469, 0x4555, 0x463e, 0x4729, 0x4816, 0x4909, 0x49f9, 0x4aeb, 0x4be3,
165 0x4cd8, 0x4dcf, 0x4ec8, 0x4fc7, 0x50c3, 0x51c1, 0x52c5, 0x53c6, 0x54c9, 0x55ce, 0x56d9, 0x57e1, 0x58eb, 0x59f6, 0x5b08, 0x5c17,
166 0x5d28, 0x5e3f, 0x5f54, 0x606a, 0x6181, 0x62a0, 0x63bb, 0x64d8, 0x65fc, 0x671c, 0x683e, 0x6962, 0x6a8d, 0x6bb5, 0x6cde, 0x6e0e,
167 0x6f3b, 0x706a, 0x719a, 0x72d1, 0x7405, 0x753b, 0x7672, 0x77b1, 0x78ec, 0x7a29, 0x7b6d, 0x7cad, 0x7def, 0x7f33, 0x807e, 0x81c6,
168 0x830f, 0x8460, 0x85ad, 0x86fb, 0x884c, 0x89a4, 0x8af8, 0x8c4e, 0x8da6, 0x8f05, 0x9061, 0x91be, 0x9323, 0x9483, 0x95e6, 0x974a,
169 0x98b7, 0x9a1f, 0x9b89, 0x9cfb, 0x9e68, 0x9fd8, 0xa149, 0xa2c2, 0xa437, 0xa5ae, 0xa726, 0xa8a7, 0xaa23, 0xaba2, 0xad28, 0xaeaa,
170 0xb02d, 0xb1b3, 0xb341, 0xb4ca, 0xb655, 0xb7e9, 0xb977, 0xbb08, 0xbc9b, 0xbe36, 0xbfcc, 0xc164, 0xc305, 0xc4a1, 0xc63e, 0xc7de,
171 0xc986, 0xcb2a, 0xcccf, 0xce76, 0xd026, 0xd1d1, 0xd37e, 0xd533, 0xd6e4, 0xd896, 0xda4a, 0xdc08, 0xddc0, 0xdf7a, 0xe13d, 0xe2fb,
172 0xe4bb, 0xe67c, 0xe847, 0xea0c, 0xebd4, 0xed9d, 0xef6f, 0xf13c, 0xf30b, 0xf4e4, 0xf6b6, 0xf88b, 0xfa62, 0xfc42, 0xfe1c, 0xffff,
173 };
174
175 const int32_t g_Vebox_BT2020_Forward_Gamma_LUT_g11[256] =
176 {
177 0x0000, 0x14bc, 0x1901, 0x1cd0, 0x2060, 0x23a3, 0x26b2, 0x29a2, 0x2c60, 0x2eff, 0x318a, 0x33f3, 0x3644, 0x388a, 0x3ab5, 0x3cce,
178 0x3ee0, 0x40db, 0x42c9, 0x44b3, 0x4689, 0x4854, 0x4a1c, 0x4bd4, 0x4d82, 0x4f2f, 0x50cd, 0x5264, 0x53f9, 0x5582, 0x5703, 0x5885,
179 0x59fb, 0x5b6a, 0x5cdb, 0x5e40, 0x5fa0, 0x6100, 0x6257, 0x63a9, 0x64fc, 0x6646, 0x6790, 0x68d2, 0x6a10, 0x6b4f, 0x6c86, 0x6db9,
180 0x6eee, 0x701a, 0x7144, 0x726f, 0x7393, 0x74b3, 0x75d6, 0x76f1, 0x780a, 0x7924, 0x7a37, 0x7b48, 0x7c5b, 0x7d68, 0x7e72, 0x7f7e,
181 0x8083, 0x8187, 0x828d, 0x838c, 0x8489, 0x8589, 0x8683, 0x877a, 0x8874, 0x8968, 0x8a5b, 0x8b4f, 0x8c3e, 0x8d2c, 0x8e1b, 0x8f06,
182 0x8fee, 0x90d9, 0x91bf, 0x92a6, 0x9389, 0x946a, 0x954e, 0x962c, 0x970a, 0x97e9, 0x98c3, 0x999d, 0x9a78, 0x9b4f, 0x9c24, 0x9cfc,
183 0x9dcf, 0x9ea1, 0x9f76, 0xa045, 0xa114, 0xa1e5, 0xa2b1, 0xa37d, 0xa44a, 0xa514, 0xa5dc, 0xa6a6, 0xa76d, 0xa832, 0xa8f9, 0xa9bd,
184 0xaa7f, 0xab44, 0xac05, 0xacc4, 0xad86, 0xae44, 0xaf02, 0xafc1, 0xb07c, 0xb137, 0xb1f4, 0xb2ad, 0xb368, 0xb41f, 0xb4d6, 0xb58e,
185 0xb643, 0xb6f8, 0xb7ae, 0xb861, 0xb913, 0xb9c7, 0xba78, 0xbb28, 0xbbda, 0xbc89, 0xbd36, 0xbde6, 0xbe93, 0xbf3f, 0xbfed, 0xc097,
186 0xc141, 0xc1ed, 0xc296, 0xc33e, 0xc3e8, 0xc48f, 0xc535, 0xc5de, 0xc683, 0xc727, 0xc7ce, 0xc871, 0xc914, 0xc9b9, 0xca5a, 0xcafc,
187 0xcb9f, 0xcc3f, 0xccde, 0xcd80, 0xce1e, 0xcebf, 0xcf5c, 0xcff9, 0xd098, 0xd134, 0xd1cf, 0xd26d, 0xd307, 0xd3a1, 0xd43d, 0xd4d6,
188 0xd56e, 0xd609, 0xd6a0, 0xd738, 0xd7d1, 0xd867, 0xd8fd, 0xd994, 0xda29, 0xdabe, 0xdb54, 0xdbe8, 0xdc7b, 0xdd10, 0xdda2, 0xde34,
189 0xdec8, 0xdf59, 0xdfea, 0xe07d, 0xe10c, 0xe19c, 0xe22d, 0xe2bc, 0xe34a, 0xe3db, 0xe468, 0xe4f5, 0xe584, 0xe611, 0xe69f, 0xe72b,
190 0xe7b6, 0xe843, 0xe8ce, 0xe958, 0xe9e4, 0xea6e, 0xeaf7, 0xeb82, 0xec0b, 0xec93, 0xed1d, 0xeda4, 0xee2c, 0xeeb5, 0xef3b, 0xefc1,
191 0xf049, 0xf0cf, 0xf154, 0xf1db, 0xf25f, 0xf2e4, 0xf36a, 0xf3ed, 0xf471, 0xf4f6, 0xf579, 0xf5fb, 0xf67f, 0xf701, 0xf783, 0xf806,
192 0xf887, 0xf907, 0xf98a, 0xfa0a, 0xfa8a, 0xfb0b, 0xfb8a, 0xfc0b, 0xfc8a, 0xfd08, 0xfd89, 0xfe06, 0xfe84, 0xff03, 0xff80, 0xffff
193 };
194
MhwVeboxInterfaceG11(PMOS_INTERFACE pInputInterface)195 MhwVeboxInterfaceG11::MhwVeboxInterfaceG11(
196 PMOS_INTERFACE pInputInterface)
197 : MhwVeboxInterfaceGeneric(pInputInterface)
198 {
199 MHW_FUNCTION_ENTER;
200 MEDIA_SYSTEM_INFO *pGtSystemInfo = nullptr;
201
202 m_veboxSettings = g_Vebox_Settings_g11;
203 m_vebox0InUse = false;
204 m_vebox1InUse = false;
205 m_veboxScalabilitySupported = false;
206 m_veboxSplitRatio = 50;
207 memset(&m_chromaParams, 0, sizeof(m_chromaParams));
208 MOS_SecureMemcpy(m_BT2020InvPixelValue, sizeof(uint32_t)* 256, g_Vebox_BT2020_Inverse_Pixel_Value_g11, sizeof(uint32_t)* 256);
209 MOS_SecureMemcpy(m_BT2020FwdPixelValue, sizeof(uint32_t)* 256, g_Vebox_BT2020_Forward_Pixel_Value_g11, sizeof(uint32_t)* 256);
210 MOS_SecureMemcpy(m_BT2020InvGammaLUT, sizeof(uint32_t)* 256, g_Vebox_BT2020_Inverse_Gamma_LUT_g11, sizeof(uint32_t)* 256);
211 MOS_SecureMemcpy(m_BT2020FwdGammaLUT, sizeof(uint32_t)* 256, g_Vebox_BT2020_Forward_Gamma_LUT_g11, sizeof(uint32_t)* 256);
212
213 MHW_CHK_NULL_NO_STATUS_RETURN(pInputInterface);
214 pGtSystemInfo = pInputInterface->pfnGetGtSystemInfo(pInputInterface);
215 MHW_CHK_NULL_NO_STATUS_RETURN(pGtSystemInfo);
216
217 if (pGtSystemInfo->VEBoxInfo.IsValid &&
218 pGtSystemInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled &&
219 pGtSystemInfo->VEBoxInfo.Instances.Bits.VEBox1Enabled)
220 {
221 m_veboxScalabilitySupported = true;
222 }
223
224 #if (_DEBUG || _RELEASE_INTERNAL)
225 MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
226 // read the "Vebox Split Ratio" user feature
227 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
228 MOS_UserFeature_ReadValue_ID(
229 nullptr,
230 __MEDIA_USER_FEATURE_VALUE_VEBOX_SPLIT_RATIO_ID,
231 &UserFeatureData,
232 m_osInterface->pOsContext);
233 m_veboxSplitRatio = UserFeatureData.u32Data;
234 #endif
235 }
236
SetVeboxIecpStateBecsc(mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD * pVeboxIecpState,PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,bool bEnableFECSC)237 void MhwVeboxInterfaceG11::SetVeboxIecpStateBecsc(
238 mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *pVeboxIecpState,
239 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,
240 bool bEnableFECSC)
241 {
242 PMHW_CAPPIPE_PARAMS pCapPipeParams = nullptr;
243 MOS_FORMAT dstFormat;
244
245 MHW_CHK_NULL_NO_STATUS_RETURN(pVeboxIecpState);
246 MHW_CHK_NULL_NO_STATUS_RETURN(pVeboxIecpParams);
247
248 pCapPipeParams = &pVeboxIecpParams->CapPipeParams;
249 MHW_CHK_NULL_NO_STATUS_RETURN(pCapPipeParams);
250 dstFormat = pVeboxIecpParams->dstFormat;
251
252 #define SET_COEFS(_c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7, _c8) \
253 { \
254 pVeboxIecpState->CscState.DW0.C0 = _c0; \
255 pVeboxIecpState->CscState.DW1.C1 = _c1; \
256 pVeboxIecpState->CscState.DW2.C2 = _c2; \
257 pVeboxIecpState->CscState.DW3.C3 = _c3; \
258 pVeboxIecpState->CscState.DW4.C4 = _c4; \
259 pVeboxIecpState->CscState.DW5.C5 = _c5; \
260 pVeboxIecpState->CscState.DW6.C6 = _c6; \
261 pVeboxIecpState->CscState.DW7.C7 = _c7; \
262 pVeboxIecpState->CscState.DW8.C8 = _c8; \
263 }
264
265 #define SET_INPUT_OFFSETS(_in1, _in2, _in3) \
266 { \
267 pVeboxIecpState->CscState.DW9.OffsetIn1 = _in1; \
268 pVeboxIecpState->CscState.DW10.OffsetIn2 = _in2; \
269 pVeboxIecpState->CscState.DW11.OffsetIn3 = _in3; \
270 }
271
272 #define SET_OUTPUT_OFFSETS(_out1, _out2, _out3) \
273 { \
274 pVeboxIecpState->CscState.DW9.OffsetOut1 = _out1; \
275 pVeboxIecpState->CscState.DW10.OffsetOut2 = _out2; \
276 pVeboxIecpState->CscState.DW11.OffsetOut3 = _out3; \
277 }
278
279 if (pCapPipeParams->bActive)
280 {
281 // Application controlled CSC operation
282 if (pCapPipeParams->BECSCParams.bActive)
283 {
284 pVeboxIecpState->CscState.DW0.TransformEnable = true;
285
286 if (IS_RGB_SWAP(dstFormat))
287 {
288 pVeboxIecpState->CscState.DW0.YuvChannelSwap = true;
289 }
290
291 // Coeff is S2.16, so multiply the floating value by 65536
292 SET_COEFS(
293 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[0][0] * 65536)),
294 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[0][1] * 65536)),
295 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[0][2] * 65536)),
296 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[1][0] * 65536)),
297 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[1][1] * 65536)),
298 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[1][2] * 65536)),
299 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[2][0] * 65536)),
300 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[2][1] * 65536)),
301 ((uint32_t)(pCapPipeParams->BECSCParams.Matrix[2][2] * 65536)));
302 SET_INPUT_OFFSETS(
303 ((uint32_t)pCapPipeParams->BECSCParams.PreOffset[0]),
304 ((uint32_t)pCapPipeParams->BECSCParams.PreOffset[1]),
305 ((uint32_t)pCapPipeParams->BECSCParams.PreOffset[2]));
306 SET_OUTPUT_OFFSETS(
307 ((uint32_t)pCapPipeParams->BECSCParams.PostOffset[0]),
308 ((uint32_t)pCapPipeParams->BECSCParams.PostOffset[1]),
309 ((uint32_t)pCapPipeParams->BECSCParams.PostOffset[2]));
310 }
311 // YUV 4:4:4 CSC to xBGR or xRGB
312 else if ((bEnableFECSC || (pVeboxIecpParams->srcFormat == Format_AYUV)) &&
313 (IS_RGB_FORMAT(dstFormat)))
314 {
315 pVeboxIecpState->CscState.DW0.TransformEnable = true;
316
317 if (IS_RGB_SWAP(dstFormat))
318 {
319 pVeboxIecpState->CscState.DW0.YuvChannelSwap = true;
320 }
321
322 // CSC matrix to convert YUV 4:4:4 to xBGR. e.g. Format_A8B8G8R8. In the
323 // event that dstFormat is xRGB, driver sets R & B channel swapping via
324 // CscState.DW0.YuvChannelSwap so a separate matrix is not needed.
325
326 if (pVeboxIecpParams->ColorSpace == MHW_CSpace_BT601)
327 {
328 SET_COEFS(76284, 0, 104595, 76284, MOS_BITFIELD_VALUE((uint32_t)-25689, 19), MOS_BITFIELD_VALUE((uint32_t)-53280, 19), 76284, 132186, 0);
329
330 SET_INPUT_OFFSETS(MOS_BITFIELD_VALUE((uint32_t)-2048, 16),
331 MOS_BITFIELD_VALUE((uint32_t)-16384, 16),
332 MOS_BITFIELD_VALUE((uint32_t)-16384, 16));
333 SET_OUTPUT_OFFSETS(0, 0, 0);
334 }
335 else if (pVeboxIecpParams->ColorSpace == MHW_CSpace_BT709)
336 {
337 SET_COEFS(76284, 0, 117506, 76284, MOS_BITFIELD_VALUE((uint32_t)-13958, 19), MOS_BITFIELD_VALUE((uint32_t)-34930, 19), 76284, 138412, 0);
338
339 SET_INPUT_OFFSETS(MOS_BITFIELD_VALUE((uint32_t)-2048, 16),
340 MOS_BITFIELD_VALUE((uint32_t)-16384, 16),
341 MOS_BITFIELD_VALUE((uint32_t)-16384, 16));
342 SET_OUTPUT_OFFSETS(0, 0, 0);
343 }
344 else
345 {
346 MHW_ASSERT(false);
347 }
348 }
349 }
350 else if (pVeboxIecpParams->bCSCEnable)
351 {
352 pVeboxIecpState->CscState.DW0.TransformEnable = true;
353
354 if (IS_RGB_SWAP(dstFormat))
355 {
356 pVeboxIecpState->CscState.DW0.YuvChannelSwap = true;
357 }
358
359 // Coeff is S2.16, so multiply the floating value by 65536
360 SET_COEFS(
361 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[0] * 65536.0F)),
362 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[1] * 65536.0F)),
363 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[2] * 65536.0F)),
364 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[3] * 65536.0F)),
365 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[4] * 65536.0F)),
366 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[5] * 65536.0F)),
367 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[6] * 65536.0F)),
368 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[7] * 65536.0F)),
369 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[8] * 65536.0F)));
370
371 // Offset is S15, but the SW offsets are calculated as 8bits,
372 // so left shift them 7bits to be in the position of MSB
373 SET_INPUT_OFFSETS(
374 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscInOffset[0] * 128.0F)),
375 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscInOffset[1] * 128.0F)),
376 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscInOffset[2] * 128.0F)));
377 SET_OUTPUT_OFFSETS(
378 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscOutOffset[0] * 128.0F)),
379 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscOutOffset[1] * 128.0F)),
380 ((uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscOutOffset[2] * 128.0F)));
381 }
382
383 pVeboxIecpState->AlphaAoiState.DW0.AlphaFromStateSelect = pVeboxIecpParams->bAlphaEnable;
384
385 // Alpha is U16, but the SW alpha is calculated as 8bits,
386 // so left shift it 8bits to be in the position of MSB
387 pVeboxIecpState->AlphaAoiState.DW0.ColorPipeAlpha = pVeboxIecpParams->wAlphaValue * 256;
388
389 #undef SET_COEFS
390 #undef SET_INPUT_OFFSETS
391 #undef SET_OUTPUT_OFFSETS
392 }
393
SetVeboxSurfaces(PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,PMHW_VEBOX_SURFACE_PARAMS pDerivedSurfaceParam,PMHW_VEBOX_SURFACE_PARAMS pSkinScoreSurfaceParam,mhw_vebox_g11_X::VEBOX_SURFACE_STATE_CMD * pVeboxSurfaceState,bool bIsOutputSurface,bool bDIEnable)394 void MhwVeboxInterfaceG11::SetVeboxSurfaces(
395 PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,
396 PMHW_VEBOX_SURFACE_PARAMS pDerivedSurfaceParam,
397 PMHW_VEBOX_SURFACE_PARAMS pSkinScoreSurfaceParam,
398 mhw_vebox_g11_X::VEBOX_SURFACE_STATE_CMD *pVeboxSurfaceState,
399 bool bIsOutputSurface,
400 bool bDIEnable)
401 {
402 uint32_t dwFormat;
403 uint32_t dwSurfaceWidth;
404 uint32_t dwSurfaceHeight;
405 uint32_t dwSurfacePitch;
406 bool bHalfPitchForChroma;
407 bool bInterleaveChroma;
408 uint16_t wUXOffset;
409 uint16_t wUYOffset;
410 uint16_t wVXOffset;
411 uint16_t wVYOffset;
412 uint8_t bBayerOffset;
413 uint8_t bBayerStride;
414 uint8_t bBayerInputAlignment;
415
416 mhw_vebox_g11_X::VEBOX_SURFACE_STATE_CMD VeboxSurfaceState;
417
418 MHW_CHK_NULL_NO_STATUS_RETURN(pSurfaceParam);
419 MHW_CHK_NULL_NO_STATUS_RETURN(pVeboxSurfaceState);
420
421 // Initialize
422 dwSurfaceWidth = 0;
423 dwSurfaceHeight = 0;
424 dwSurfacePitch = 0;
425 bHalfPitchForChroma = false;
426 bInterleaveChroma = false;
427 wUXOffset = 0;
428 wUYOffset = 0;
429 wVXOffset = 0;
430 wVYOffset = 0;
431 bBayerOffset = 0;
432 bBayerStride = 0;
433 bBayerInputAlignment = 0;
434 *pVeboxSurfaceState = VeboxSurfaceState;
435
436 switch (pSurfaceParam->Format)
437 {
438 case Format_NV12:
439 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PLANAR4208;
440 bInterleaveChroma = true;
441 wUYOffset = (uint16_t)pSurfaceParam->dwUYoffset;
442 break;
443
444 case Format_YUYV:
445 case Format_YUY2:
446 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBNORMAL;
447 break;
448
449 case Format_UYVY:
450 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBSWAPY;
451 break;
452
453 case Format_AYUV:
454 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED444A8;
455 break;
456
457 case Format_Y416:
458 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED44416;
459 break;
460
461 case Format_Y410:
462 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED44410;
463 break;
464
465 case Format_YVYU:
466 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBSWAPUV;
467 break;
468
469 case Format_VYUY:
470 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBSWAPUVY;
471 break;
472
473 case Format_A8B8G8R8:
474 case Format_X8B8G8R8:
475 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R8G8B8A8UNORMR8G8B8A8UNORMSRGB;
476 break;
477
478 case Format_A16B16G16R16:
479 case Format_A16R16G16B16:
480 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R16G16B16A16;
481 break;
482
483 case Format_L8:
484 case Format_P8:
485 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_Y8UNORM;
486 break;
487
488 case Format_IRW0:
489 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
490 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISBLUE;
491 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
492 break;
493
494 case Format_IRW1:
495 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
496 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISRED;
497 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
498 break;
499
500 case Format_IRW2:
501 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
502 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISRED;
503 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
504 break;
505
506 case Format_IRW3:
507 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
508 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISBLUE;
509 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
510 break;
511
512 case Format_IRW4:
513 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
514 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISBLUE;
515 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
516 break;
517
518 case Format_IRW5:
519 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
520 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISRED;
521 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
522 break;
523
524 case Format_IRW6:
525 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
526 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISRED;
527 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
528 break;
529
530 case Format_IRW7:
531 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
532 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISBLUE;
533 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
534 break;
535
536 case Format_P010:
537 case Format_P016:
538 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PLANAR42016;
539 bInterleaveChroma = true;
540 wUYOffset = (uint16_t)pSurfaceParam->dwUYoffset;
541 break;
542
543 case Format_A8R8G8B8:
544 case Format_X8R8G8B8:
545 if (bIsOutputSurface)
546 {
547 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_B8G8R8A8UNORM;
548 }
549 else
550 {
551 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R8G8B8A8UNORMR8G8B8A8UNORMSRGB;
552 }
553 break;
554
555 case Format_R10G10B10A2:
556 case Format_B10G10R10A2:
557 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R10G10B10A2UNORMR10G10B10A2UNORMSRGB;
558 break;
559
560 case Format_Y216:
561 case Format_Y210:
562 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED42216;
563 break;
564
565 case Format_P216:
566 case Format_P210:
567 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PLANAR42216;
568 wUYOffset = (uint16_t)pSurfaceParam->dwUYoffset;
569 break;
570
571 default:
572 MHW_ASSERTMESSAGE("Unsupported format.");
573 goto finish;
574 break;
575 }
576
577 if (!bIsOutputSurface)
578 {
579 // camera pipe will use 10/12/14 for LSB, 0 for MSB. For other pipeline,
580 // dwBitDepth is inherited from pSrc->dwDepth which may not among (0,10,12,14)
581 // For such cases should use MSB as default value.
582 switch (pSurfaceParam->dwBitDepth)
583 {
584 case 10:
585 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_10BITLSBALIGNEDDATA;
586 break;
587
588 case 12:
589 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_12BITLSBALIGNEDDATA;
590 break;
591
592 case 14:
593 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_14BITLSBALIGNEDDATA;
594 break;
595
596 case 0:
597 default:
598 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_MSBALIGNEDDATA;
599 break;
600 }
601 }
602 else
603 {
604 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_MSBALIGNEDDATA;
605 }
606
607 // adjust boundary for vebox
608 VeboxAdjustBoundary(
609 pSurfaceParam,
610 &dwSurfaceWidth,
611 &dwSurfaceHeight,
612 bDIEnable);
613
614 dwSurfacePitch = (pSurfaceParam->TileType == MOS_TILE_LINEAR) ? MOS_ALIGN_CEIL(pSurfaceParam->dwPitch, MHW_VEBOX_LINEAR_PITCH) : pSurfaceParam->dwPitch;
615
616 pVeboxSurfaceState->DW1.SurfaceIdentification = bIsOutputSurface;
617 pVeboxSurfaceState->DW2.Width = dwSurfaceWidth - 1;
618 pVeboxSurfaceState->DW2.Height = dwSurfaceHeight - 1;
619
620 pVeboxSurfaceState->DW3.HalfPitchForChroma = bHalfPitchForChroma;
621 pVeboxSurfaceState->DW3.InterleaveChroma = bInterleaveChroma;
622 pVeboxSurfaceState->DW3.SurfaceFormat = dwFormat;
623 pVeboxSurfaceState->DW3.BayerInputAlignment = bBayerInputAlignment;
624 pVeboxSurfaceState->DW3.BayerPatternOffset = bBayerOffset;
625 pVeboxSurfaceState->DW3.BayerPatternFormat = bBayerStride;
626 pVeboxSurfaceState->DW3.SurfacePitch = dwSurfacePitch - 1;
627 pVeboxSurfaceState->DW3.TiledSurface = (pSurfaceParam->TileType != MOS_TILE_LINEAR) ? true : false;
628 pVeboxSurfaceState->DW3.TileWalk = (pSurfaceParam->TileType == MOS_TILE_Y)
629 ? VeboxSurfaceState.TILE_WALK_TILEWALKYMAJOR
630 : VeboxSurfaceState.TILE_WALK_TILEWALKXMAJOR;
631 pVeboxSurfaceState->DW4.XOffsetForU = wUXOffset;
632 pVeboxSurfaceState->DW4.YOffsetForU = wUYOffset;
633 pVeboxSurfaceState->DW5.XOffsetForV = wVXOffset;
634 pVeboxSurfaceState->DW5.YOffsetForV = wVYOffset;
635
636 // May fix this for stereo surfaces
637 pVeboxSurfaceState->DW6.YOffsetForFrame = pSurfaceParam->dwYoffset;
638 pVeboxSurfaceState->DW6.XOffsetForFrame = 0;
639
640 if (pDerivedSurfaceParam->dwPitch != 0)
641 pVeboxSurfaceState->DW7.DerivedSurfacePitch = pDerivedSurfaceParam->dwPitch - 1;
642 pVeboxSurfaceState->DW8.SurfacePitchForSkinScoreOutputSurfaces = (bIsOutputSurface && pSkinScoreSurfaceParam->bActive) ? (pSkinScoreSurfaceParam->dwPitch - 1) : 0;
643
644 finish:
645 return;
646 }
647
VeboxAdjustBoundary(PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,uint32_t * pdwSurfaceWidth,uint32_t * pdwSurfaceHeight,bool bDIEnable)648 MOS_STATUS MhwVeboxInterfaceG11::VeboxAdjustBoundary(
649 PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,
650 uint32_t *pdwSurfaceWidth,
651 uint32_t *pdwSurfaceHeight,
652 bool bDIEnable)
653 {
654 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
655
656 MHW_CHK_NULL(pSurfaceParam);
657 MHW_CHK_NULL(pdwSurfaceWidth);
658 MHW_CHK_NULL(pdwSurfaceHeight);
659 MHW_CHK_STATUS(AdjustBoundary(pSurfaceParam, pdwSurfaceWidth, pdwSurfaceHeight, bDIEnable));
660
661 finish:
662 return eStatus;
663 }
664
AddVeboxState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams,bool bCmBuffer)665 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxState(
666 PMOS_COMMAND_BUFFER pCmdBuffer,
667 PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams,
668 bool bCmBuffer)
669 {
670 MOS_STATUS eStatus;
671 PMOS_INTERFACE pOsInterface;
672 PMOS_CONTEXT pOsContext = nullptr;
673 PMOS_RESOURCE pVeboxParamResource = nullptr;
674 PMOS_RESOURCE pVeboxHeapResource = nullptr;
675 PMHW_VEBOX_HEAP pVeboxHeap;
676 PMHW_VEBOX_MODE pVeboxMode;
677 PMHW_VEBOX_CHROMA_SAMPLING pChromaSampling;
678 PMHW_VEBOX_3D_LUT pLUT3D;
679 uint32_t uiInstanceBaseAddr = 0;
680 MHW_RESOURCE_PARAMS ResourceParams;
681 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
682 mhw_vebox_g11_X::VEBOX_STATE_CMD cmd;
683
684 MHW_CHK_NULL(m_osInterface);
685 MHW_CHK_NULL(m_osInterface->pOsContext);
686 MHW_CHK_NULL(pCmdBuffer);
687 MHW_CHK_NULL(pVeboxStateCmdParams);
688
689 // Initialize
690 eStatus = MOS_STATUS_SUCCESS;
691 pOsInterface = m_osInterface;
692 pOsContext = m_osInterface->pOsContext;
693 pVeboxMode = &pVeboxStateCmdParams->VeboxMode;
694 pLUT3D = &pVeboxStateCmdParams->LUT3D;
695 pChromaSampling = &pVeboxStateCmdParams->ChromaSampling;
696
697 if (!pVeboxStateCmdParams->bNoUseVeboxHeap)
698 {
699 MHW_CHK_NULL(m_veboxHeap);
700
701 pVeboxHeap = m_veboxHeap;
702 if (bCmBuffer)
703 {
704 pVeboxParamResource = pVeboxStateCmdParams->pVeboxParamSurf;
705 }
706 else
707 {
708 pVeboxHeapResource = pVeboxStateCmdParams->bUseVeboxHeapKernelResource ? &pVeboxHeap->KernelResource : &pVeboxHeap->DriverResource;
709
710 // Calculate the instance base address
711 uiInstanceBaseAddr = pVeboxHeap->uiInstanceSize * pVeboxHeap->uiCurState;
712 }
713
714 TraceIndirectStateInfo(*pCmdBuffer, *pOsContext, bCmBuffer, pVeboxStateCmdParams->bUseVeboxHeapKernelResource);
715
716 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
717 if (bCmBuffer)
718 {
719 ResourceParams.presResource = pVeboxParamResource;
720 ResourceParams.dwOffset = pVeboxHeap->uiDndiStateOffset;
721 }
722 else
723 {
724 ResourceParams.presResource = pVeboxHeapResource;
725 ResourceParams.dwOffset = pVeboxHeap->uiDndiStateOffset + uiInstanceBaseAddr;
726 }
727 ResourceParams.pdwCmd = & (cmd.DW2.Value);
728 ResourceParams.dwLocationInCmd = 2;
729 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
730
731 MHW_CHK_STATUS(pfnAddResourceToCmd(
732 pOsInterface,
733 pCmdBuffer,
734 &ResourceParams));
735
736 HalOcaInterface::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, ResourceParams.presResource, ResourceParams.dwOffset, false, m_veboxSettings.uiDndiStateSize);
737
738 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
739 if (bCmBuffer)
740 {
741 ResourceParams.presResource = pVeboxParamResource;
742 ResourceParams.dwOffset = pVeboxHeap->uiIecpStateOffset;
743 }
744 else
745 {
746 ResourceParams.presResource = pVeboxHeapResource;
747 ResourceParams.dwOffset = pVeboxHeap->uiIecpStateOffset + uiInstanceBaseAddr;
748 }
749 ResourceParams.pdwCmd = & (cmd.DW4.Value);
750 ResourceParams.dwLocationInCmd = 4;
751 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
752 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
753
754 MHW_CHK_STATUS(pfnAddResourceToCmd(
755 pOsInterface,
756 pCmdBuffer,
757 &ResourceParams));
758
759 HalOcaInterface::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, ResourceParams.presResource, ResourceParams.dwOffset, false, m_veboxSettings.uiIecpStateSize);
760
761 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
762 if (bCmBuffer)
763 {
764 ResourceParams.presResource = pVeboxParamResource;
765 ResourceParams.dwOffset = pVeboxHeap->uiGamutStateOffset;
766 }
767 else
768 {
769 ResourceParams.presResource = pVeboxHeapResource;
770 ResourceParams.dwOffset = pVeboxHeap->uiGamutStateOffset + uiInstanceBaseAddr;
771 }
772 ResourceParams.pdwCmd = & (cmd.DW6.Value);
773 ResourceParams.dwLocationInCmd = 6;
774 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
775 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
776
777 MHW_CHK_STATUS(pfnAddResourceToCmd(
778 pOsInterface,
779 pCmdBuffer,
780 &ResourceParams));
781
782 HalOcaInterface::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, ResourceParams.presResource, ResourceParams.dwOffset, false, m_veboxSettings.uiGamutStateSize);
783
784 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
785 if (bCmBuffer)
786 {
787 ResourceParams.presResource = pVeboxParamResource;
788 ResourceParams.dwOffset = pVeboxHeap->uiVertexTableOffset;
789 }
790 else
791 {
792 ResourceParams.presResource = pVeboxHeapResource;
793 ResourceParams.dwOffset = pVeboxHeap->uiVertexTableOffset + uiInstanceBaseAddr;
794 }
795 ResourceParams.pdwCmd = & (cmd.DW8.Value);
796 ResourceParams.dwLocationInCmd = 8;
797 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
798 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
799
800 MHW_CHK_STATUS(pfnAddResourceToCmd(
801 pOsInterface,
802 pCmdBuffer,
803 &ResourceParams));
804
805 HalOcaInterface::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, ResourceParams.presResource, ResourceParams.dwOffset, false, m_veboxSettings.uiVertexTableSize);
806
807 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
808 if (bCmBuffer)
809 {
810 ResourceParams.presResource = pVeboxParamResource;
811 ResourceParams.dwOffset = pVeboxHeap->uiCapturePipeStateOffset;
812 }
813 else
814 {
815 ResourceParams.presResource = pVeboxHeapResource;
816 ResourceParams.dwOffset = pVeboxHeap->uiCapturePipeStateOffset + uiInstanceBaseAddr;
817 }
818
819 ResourceParams.pdwCmd = & (cmd.DW10.Value);
820 ResourceParams.dwLocationInCmd = 10;
821 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
822 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
823
824 MHW_CHK_STATUS(pfnAddResourceToCmd(
825 pOsInterface,
826 pCmdBuffer,
827 &ResourceParams));
828
829 HalOcaInterface::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, ResourceParams.presResource, ResourceParams.dwOffset, false, m_veboxSettings.uiCapturePipeStateSize);
830
831 if (pVeboxStateCmdParams->pLaceLookUpTables)
832 {
833 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
834 ResourceParams.presResource = pVeboxStateCmdParams->pLaceLookUpTables;
835 ResourceParams.dwOffset = 0;
836 ResourceParams.pdwCmd = & (cmd.DW12.Value);
837 ResourceParams.dwLocationInCmd = 12;
838 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
839 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
840
841 MHW_CHK_STATUS(pfnAddResourceToCmd(
842 pOsInterface,
843 pCmdBuffer,
844 &ResourceParams));
845 }
846
847 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
848 if (bCmBuffer)
849 {
850 ResourceParams.presResource = pVeboxParamResource;
851 ResourceParams.dwOffset = pVeboxHeap->uiGammaCorrectionStateOffset;
852 }
853 else
854 {
855 ResourceParams.presResource = pVeboxHeapResource;
856 ResourceParams.dwOffset = pVeboxHeap->uiGammaCorrectionStateOffset + uiInstanceBaseAddr;
857 }
858 ResourceParams.pdwCmd = & (cmd.DW14_15.Value[0]);
859 ResourceParams.dwLocationInCmd = 14;
860 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
861 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
862
863 MHW_CHK_STATUS(pfnAddResourceToCmd(
864 pOsInterface,
865 pCmdBuffer,
866 &ResourceParams));
867
868 HalOcaInterface::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, ResourceParams.presResource, ResourceParams.dwOffset, false, m_veboxSettings.uiGammaCorrectionStateSize);
869
870 if (pVeboxStateCmdParams->pVebox3DLookUpTables)
871 {
872 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
873 ResourceParams.presResource = pVeboxStateCmdParams->pVebox3DLookUpTables;
874 ResourceParams.dwOffset = 0;
875 ResourceParams.pdwCmd = &(cmd.DW16.Value);
876 ResourceParams.dwLocationInCmd = 16;
877 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
878 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
879
880 MHW_CHK_STATUS(pfnAddResourceToCmd(
881 pOsInterface,
882 pCmdBuffer,
883 &ResourceParams));
884 }
885 }
886 else
887 {
888 // Allocate Resource to avoid Page Fault issue since HW will access it
889 if (Mos_ResourceIsNull(&pVeboxStateCmdParams->DummyIecpResource))
890 {
891 MOS_ZeroMemory(&AllocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
892
893 AllocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
894 AllocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
895 AllocParamsForBufferLinear.Format = Format_Buffer;
896 AllocParamsForBufferLinear.dwBytes = m_veboxSettings.uiIecpStateSize;
897 AllocParamsForBufferLinear.pBufName = "DummyIecpResource";
898
899 MHW_CHK_STATUS(pOsInterface->pfnAllocateResource(
900 pOsInterface,
901 &AllocParamsForBufferLinear,
902 &pVeboxStateCmdParams->DummyIecpResource));
903 }
904
905 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
906 ResourceParams.presResource = &pVeboxStateCmdParams->DummyIecpResource;
907 ResourceParams.dwOffset = 0;
908 ResourceParams.pdwCmd = &(cmd.DW4.Value);
909 ResourceParams.dwLocationInCmd = 4;
910 ResourceParams.HwCommandType = MOS_VEBOX_STATE;
911 ResourceParams.dwSharedMocsOffset = 1 - ResourceParams.dwLocationInCmd;
912
913 MHW_CHK_STATUS(pfnAddResourceToCmd(
914 pOsInterface,
915 pCmdBuffer,
916 &ResourceParams));
917
918 HalOcaInterface::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, ResourceParams.presResource, 0, true, 0);
919 }
920
921 MHW_CHK_NULL(pVeboxMode);
922 MHW_CHK_NULL(pLUT3D);
923 MHW_CHK_NULL(pChromaSampling);
924
925 cmd.DW1.ColorGamutExpansionEnable = pVeboxMode->ColorGamutExpansionEnable;
926 cmd.DW1.ColorGamutCompressionEnable = pVeboxMode->ColorGamutCompressionEnable;
927 cmd.DW1.GlobalIecpEnable = pVeboxMode->GlobalIECPEnable;
928 cmd.DW1.DnEnable = pVeboxMode->DNEnable;
929 cmd.DW1.DiEnable = pVeboxMode->DIEnable;
930 cmd.DW1.DnDiFirstFrame = pVeboxMode->DNDIFirstFrame;
931 cmd.DW1.DiOutputFrames = pVeboxMode->DIOutputFrames;
932 cmd.DW1.DemosaicEnable = pVeboxMode->DemosaicEnable;
933 cmd.DW1.VignetteEnable = pVeboxMode->VignetteEnable;
934 cmd.DW1.AlphaPlaneEnable = pVeboxMode->AlphaPlaneEnable;
935 cmd.DW1.HotPixelFilteringEnable = pVeboxMode->HotPixelFilteringEnable;
936 cmd.DW1.LaceCorrectionEnable = pVeboxMode->LACECorrectionEnable;
937 cmd.DW1.DisableEncoderStatistics = pVeboxMode->DisableEncoderStatistics;
938 cmd.DW1.DisableTemporalDenoiseFilter = pVeboxMode->DisableTemporalDenoiseFilter;
939 cmd.DW1.SinglePipeEnable = pVeboxMode->SinglePipeIECPEnable;
940 cmd.DW1.ScalarMode = pVeboxMode->ScalarMode;
941 cmd.DW1.ForwardGammaCorrectionEnable = pVeboxMode->ForwardGammaCorrectionEnable;
942
943 cmd.DW17.ArbitrationPriorityControlForLut3D = pLUT3D->ArbitrationPriorityControl;
944 // In GmmCachePolicyExt.h, Gen9/Gen10/Gen11 has the same definition for MEMORY_OBJECT_CONTROL_STATE.
945 // In MHW_MEMORY_OBJECT_CONTROL_PARAMS, we only defined Gen9 which intended to use for Gen9 later, so reuse Gen9 index.
946 cmd.DW17.Lut3DMOCStable = pVeboxStateCmdParams->Vebox3DLookUpTablesSurfCtrl.Gen9.Index;
947 cmd.DW18.Lut3DEnable = pLUT3D->Lut3dEnable;
948 cmd.DW18.Lut3DSize = pLUT3D->Lut3dSize;
949
950 cmd.DW18.ChromaUpsamplingCoSitedHorizontalOffset = pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset;
951 cmd.DW18.ChromaUpsamplingCoSitedVerticalOffset = pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset;
952 cmd.DW18.ChromaDownsamplingCoSitedHorizontalOffset = pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset;
953 cmd.DW18.ChromaDownsamplingCoSitedVerticalOffset = pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset;
954 cmd.DW18.BypassChromaUpsampling = pChromaSampling->BypassChromaUpsampling;
955 cmd.DW18.BypassChromaDownsampling = pChromaSampling->BypassChromaDownsampling;
956
957 pOsInterface->pfnAddCommand(pCmdBuffer, &cmd, cmd.byteSize);
958
959 finish:
960 return eStatus;
961 }
962
AddVeboxDiIecp(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)963 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxDiIecp(
964 PMOS_COMMAND_BUFFER pCmdBuffer,
965 PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
966 {
967 MOS_STATUS eStatus;
968 PMOS_INTERFACE pOsInterface;
969 MHW_RESOURCE_PARAMS ResourceParams;
970
971 mhw_vebox_g11_X::VEB_DI_IECP_CMD cmd;
972 MHW_CHK_NULL(m_osInterface);
973 MHW_CHK_NULL(pCmdBuffer);
974 MHW_CHK_NULL(pVeboxDiIecpCmdParams);
975 MHW_ASSERT(MOS_IS_ALIGNED(pVeboxDiIecpCmdParams->dwCurrInputSurfOffset, MHW_PAGE_SIZE)); // offset should be aligned with 4KB
976 MHW_ASSERT(MOS_IS_ALIGNED(pVeboxDiIecpCmdParams->dwPrevInputSurfOffset, MHW_PAGE_SIZE)); // offset should be aligned with 4KB
977
978 // Initialize
979 eStatus = MOS_STATUS_SUCCESS;
980 pOsInterface = m_osInterface;
981
982 if (pVeboxDiIecpCmdParams->pOsResCurrInput)
983 {
984 cmd.DW2.CurrentFrameSurfaceControlBitsMemoryCompressionEnable =
985 (pVeboxDiIecpCmdParams->CurInputSurfMMCState != MOS_MEMCOMP_DISABLED) ? 1 : 0;
986 cmd.DW2.CurrentFrameSurfaceControlBitsMemoryCompressionMode =
987 (pVeboxDiIecpCmdParams->CurInputSurfMMCState == MOS_MEMCOMP_HORIZONTAL) ? 0 : 1;
988
989 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
990 ResourceParams.dwLsbNum = MHW_VEBOX_DI_IECP_SHIFT;
991 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResCurrInput;
992 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->dwCurrInputSurfOffset;
993 ResourceParams.pdwCmd = & (cmd.DW2.Value);
994 ResourceParams.dwLocationInCmd = 2;
995 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
996
997 MHW_CHK_STATUS(pfnAddResourceToCmd(
998 pOsInterface,
999 pCmdBuffer,
1000 &ResourceParams));
1001 }
1002
1003 // Remove this after VPHAL moving to new cmd definition --- assign MOCS/MMC bits directly
1004 if (pVeboxDiIecpCmdParams->CurInputSurfMMCState == 0)
1005 {
1006 // bit 0 ~ 10 is MOCS/MMC bits
1007 cmd.DW2.Value = (cmd.DW2.Value & 0xFFFFF800) + pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value;
1008 }
1009
1010 if (pVeboxDiIecpCmdParams->pOsResPrevInput)
1011 {
1012 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1013 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResPrevInput;
1014 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->PrevInputSurfCtrl.Value + pVeboxDiIecpCmdParams->dwPrevInputSurfOffset;
1015 ResourceParams.pdwCmd = & (cmd.DW4.Value);
1016 ResourceParams.dwLocationInCmd = 4;
1017 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1018
1019 MHW_CHK_STATUS(pfnAddResourceToCmd(
1020 pOsInterface,
1021 pCmdBuffer,
1022 &ResourceParams));
1023
1024 // If Previous input has chroma plane, send token to bind the chroma plane
1025 if (pOsInterface->bPitchAndUVPatchingNeeded)
1026 {
1027 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1028 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResPrevInput;
1029 ResourceParams.patchType = MOS_PATCH_TYPE_BIND_ONLY;
1030 ResourceParams.bIsWritable = false;
1031 ResourceParams.pdwCmd = &(cmd.DW4.Value);
1032 ResourceParams.dwLocationInCmd = 4;
1033 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1034
1035 MHW_CHK_STATUS(pfnAddResourceToCmd(
1036 pOsInterface,
1037 pCmdBuffer,
1038 &ResourceParams));
1039 }
1040 }
1041
1042 if (pVeboxDiIecpCmdParams->pOsResStmmInput)
1043 {
1044 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1045 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResStmmInput;
1046 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->StmmInputSurfCtrl.Value;
1047 ResourceParams.pdwCmd = & (cmd.DW6.Value);
1048 ResourceParams.dwLocationInCmd = 6;
1049 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1050
1051 MHW_CHK_STATUS(pfnAddResourceToCmd(
1052 pOsInterface,
1053 pCmdBuffer,
1054 &ResourceParams));
1055 }
1056
1057 if (pVeboxDiIecpCmdParams->pOsResStmmOutput)
1058 {
1059 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1060 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResStmmOutput;
1061 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->StmmOutputSurfCtrl.Value;
1062 ResourceParams.pdwCmd = & (cmd.DW8.Value);
1063 ResourceParams.dwLocationInCmd = 8;
1064 ResourceParams.bIsWritable = true;
1065 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1066
1067 MHW_CHK_STATUS(pfnAddResourceToCmd(
1068 pOsInterface,
1069 pCmdBuffer,
1070 &ResourceParams));
1071 }
1072
1073 if (pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput)
1074 {
1075 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1076 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput;
1077 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->DenoisedCurrOutputSurfCtrl.Value;
1078 ResourceParams.pdwCmd = & (cmd.DW10.Value);
1079 ResourceParams.dwLocationInCmd = 10;
1080 ResourceParams.bIsWritable = true;
1081 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1082
1083 MHW_CHK_STATUS(pfnAddResourceToCmd(
1084 pOsInterface,
1085 pCmdBuffer,
1086 &ResourceParams));
1087
1088 // If DN Current Output has chroma plane , send token to bind the chroma plane
1089 // and mark it writeable
1090 if (pOsInterface->bPitchAndUVPatchingNeeded)
1091 {
1092 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1093 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput;
1094 ResourceParams.patchType = MOS_PATCH_TYPE_BIND_ONLY;
1095 ResourceParams.pdwCmd = &(cmd.DW10.Value);
1096 ResourceParams.dwLocationInCmd = 10;
1097 ResourceParams.bIsWritable = true;
1098 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1099
1100 MHW_CHK_STATUS(pfnAddResourceToCmd(
1101 pOsInterface,
1102 pCmdBuffer,
1103 &ResourceParams));
1104 }
1105 }
1106 if (pVeboxDiIecpCmdParams->pOsResCurrOutput &&
1107 !Mos_ResourceIsNull(pVeboxDiIecpCmdParams->pOsResCurrOutput))
1108 {
1109 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1110 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResCurrOutput;
1111 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value + pVeboxDiIecpCmdParams->dwCurrOutputSurfOffset;
1112 ResourceParams.pdwCmd = & (cmd.DW12.Value);
1113 ResourceParams.dwLocationInCmd = 12;
1114 ResourceParams.bIsWritable = true;
1115 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1116
1117 MHW_CHK_STATUS(pfnAddResourceToCmd(
1118 pOsInterface,
1119 pCmdBuffer,
1120 &ResourceParams));
1121 }
1122
1123 if (pVeboxDiIecpCmdParams->pOsResPrevOutput)
1124 {
1125 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1126 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResPrevOutput;
1127 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->PrevOutputSurfCtrl.Value;
1128 ResourceParams.pdwCmd = & (cmd.DW14.Value);
1129 ResourceParams.dwLocationInCmd = 14;
1130 ResourceParams.bIsWritable = true;
1131 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1132
1133 MHW_CHK_STATUS(pfnAddResourceToCmd(
1134 pOsInterface,
1135 pCmdBuffer,
1136 &ResourceParams));
1137
1138 // If DN Current Output has chroma plane , send token to bind the chroma plane
1139 // and mark it writeable
1140 if (pOsInterface->bPitchAndUVPatchingNeeded)
1141 {
1142 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1143 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResPrevOutput;
1144 ResourceParams.patchType = MOS_PATCH_TYPE_BIND_ONLY;
1145 ResourceParams.pdwCmd = &(cmd.DW14.Value);
1146 ResourceParams.dwLocationInCmd = 14;
1147 ResourceParams.bIsWritable = true;
1148 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1149
1150 MHW_CHK_STATUS(pfnAddResourceToCmd(
1151 pOsInterface,
1152 pCmdBuffer,
1153 &ResourceParams));
1154 }
1155 }
1156
1157 if (pVeboxDiIecpCmdParams->pOsResStatisticsOutput)
1158 {
1159 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1160 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResStatisticsOutput;
1161 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->StatisticsOutputSurfCtrl.Value;
1162 ResourceParams.pdwCmd = & (cmd.DW16.Value);
1163 ResourceParams.dwLocationInCmd = 16;
1164 ResourceParams.bIsWritable = true;
1165 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1166
1167 MHW_CHK_STATUS(pfnAddResourceToCmd(
1168 pOsInterface,
1169 pCmdBuffer,
1170 &ResourceParams));
1171 }
1172
1173 if (pVeboxDiIecpCmdParams->pOsResAlphaOrVignette)
1174 {
1175 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1176 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResAlphaOrVignette;
1177 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->AlphaOrVignetteSurfCtrl.Value;
1178 ResourceParams.pdwCmd = & (cmd.DW18.Value);
1179 ResourceParams.dwLocationInCmd = 18;
1180 ResourceParams.bIsWritable = true;
1181 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1182
1183 MHW_CHK_STATUS(pfnAddResourceToCmd(
1184 pOsInterface,
1185 pCmdBuffer,
1186 &ResourceParams));
1187 }
1188
1189 if (pVeboxDiIecpCmdParams->pOsResLaceOrAceOrRgbHistogram)
1190 {
1191 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1192 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResLaceOrAceOrRgbHistogram;
1193 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->LaceOrAceOrRgbHistogramSurfCtrl.Value;
1194 ResourceParams.pdwCmd = & (cmd.DW20.Value);
1195 ResourceParams.dwLocationInCmd = 20;
1196 ResourceParams.bIsWritable = true;
1197 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1198
1199 MHW_CHK_STATUS(pfnAddResourceToCmd(
1200 pOsInterface,
1201 pCmdBuffer,
1202 &ResourceParams));
1203 }
1204
1205 if (pVeboxDiIecpCmdParams->pOsResSkinScoreSurface)
1206 {
1207 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
1208 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResSkinScoreSurface;
1209 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->SkinScoreSurfaceSurfCtrl.Value;
1210 ResourceParams.pdwCmd = & (cmd.DW22.Value);
1211 ResourceParams.dwLocationInCmd = 22;
1212 ResourceParams.bIsWritable = true;
1213 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
1214
1215 MHW_CHK_STATUS(pfnAddResourceToCmd(
1216 pOsInterface,
1217 pCmdBuffer,
1218 &ResourceParams));
1219 }
1220
1221 if (m_vebox0InUse == false && m_vebox1InUse == false)
1222 {
1223 cmd.DW1.EndingX = pVeboxDiIecpCmdParams->dwEndingX;
1224 cmd.DW1.StartingX = pVeboxDiIecpCmdParams->dwStartingX;
1225 }
1226 else if (m_veboxScalabilitySupported)
1227 {
1228 uint32_t iMediumX;
1229 MHW_ASSERT(pVeboxDiIecpCmdParams->dwEndingX >= 127);
1230
1231 // Fix vebox hang issue, vebox scalability requires 64 alignment
1232 iMediumX = MOS_ALIGN_FLOOR(((pVeboxDiIecpCmdParams->dwEndingX + 1) * m_veboxSplitRatio / 100), 64);
1233 iMediumX = MOS_CLAMP_MIN_MAX(iMediumX, 64, (pVeboxDiIecpCmdParams->dwEndingX - 63));
1234
1235 if (m_vebox0InUse == true &&
1236 m_vebox1InUse == false)
1237 {
1238 cmd.DW1.EndingX = iMediumX - 1;
1239 cmd.DW1.StartingX = pVeboxDiIecpCmdParams->dwStartingX;
1240 }
1241 else if (m_vebox0InUse == false &&
1242 m_vebox1InUse == true)
1243 {
1244 cmd.DW1.EndingX = pVeboxDiIecpCmdParams->dwEndingX;
1245 cmd.DW1.StartingX = iMediumX;
1246 }
1247 else
1248 {
1249 MHW_ASSERTMESSAGE("Unsupported Vebox Scalability Settings");
1250 }
1251 }
1252 else
1253 {
1254 MHW_ASSERTMESSAGE("Unsupported Vebox Scalability Settings");
1255 }
1256
1257 pOsInterface->pfnAddCommand(pCmdBuffer, &cmd, cmd.byteSize);
1258
1259 finish:
1260 return eStatus;
1261 }
1262
AddVeboxGamutState(PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,PMHW_VEBOX_GAMUT_PARAMS pVeboxGamutParams)1263 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxGamutState(
1264 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,
1265 PMHW_VEBOX_GAMUT_PARAMS pVeboxGamutParams)
1266 {
1267 PMHW_VEBOX_HEAP pVeboxHeap;
1268 uint32_t uiOffset;
1269 uint32_t i;
1270 double dInverseGamma = 0;
1271 double dForwardGamma = 0;
1272 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1273 uint16_t usGE_Values[256][8] = {0};
1274 bool bEnableCCM = false;
1275
1276 mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *pIecpState;
1277 mhw_vebox_g11_X::VEBOX_GAMUT_CONTROL_STATE_CMD *pGamutState, gamutCmd;
1278 mhw_vebox_g11_X::Gamut_Expansion_Gamma_Correction_CMD *pVeboxGEGammaCorrection, VeboxGEGammaCorrection;
1279
1280 MHW_CHK_NULL(pVeboxGamutParams);
1281 MHW_CHK_NULL(m_veboxHeap);
1282
1283 pVeboxHeap = m_veboxHeap;
1284 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
1285
1286 pIecpState =
1287 (mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *)(pVeboxHeap->pLockedDriverResourceMem +
1288 pVeboxHeap->uiIecpStateOffset +
1289 uiOffset);
1290 pVeboxGEGammaCorrection =
1291 (mhw_vebox_g11_X::Gamut_Expansion_Gamma_Correction_CMD *)(pVeboxHeap->pLockedDriverResourceMem +
1292 pVeboxHeap->uiGamutStateOffset +
1293 uiOffset);
1294
1295 MHW_CHK_NULL(pIecpState);
1296 MHW_CHK_NULL(pVeboxGEGammaCorrection);
1297
1298 // Must initialize VeboxIecpState even if it is not used because GCE
1299 // requires GlobalIECP enable bit to be turned on
1300 if (!pVeboxIecpParams)
1301 {
1302 IecpStateInitialization(pIecpState);
1303 }
1304 pGamutState = &pIecpState->GamutState;
1305 MHW_CHK_NULL(pGamutState);
1306
1307 if (pVeboxGamutParams->GCompMode != MHW_GAMUT_MODE_NONE)
1308 {
1309 if (pVeboxGamutParams->GCompMode == MHW_GAMUT_MODE_BASIC)
1310 {
1311 pGamutState->DW15.Fullrangemappingenable = false;
1312
1313 if (pVeboxGamutParams->GCompBasicMode == gamutCmd.GCC_BASICMODESELECTION_SCALINGFACTOR)
1314 {
1315 pGamutState->DW17.GccBasicmodeselection = gamutCmd.GCC_BASICMODESELECTION_SCALINGFACTOR;
1316 pGamutState->DW17.Basicmodescalingfactor =
1317 pVeboxGamutParams->iBasicModeScalingFactor;
1318 }
1319 }
1320 else if (pVeboxGamutParams->GCompMode == MHW_GAMUT_MODE_ADVANCED)
1321 {
1322 pGamutState->DW15.Fullrangemappingenable = true;
1323 pGamutState->DW15.D1Out = pVeboxGamutParams->iDout;
1324 pGamutState->DW15.DOutDefault = pVeboxGamutParams->iDoutDefault;
1325 pGamutState->DW15.DInDefault = pVeboxGamutParams->iDinDefault;
1326 pGamutState->DW16.D1In = pVeboxGamutParams->iDin;
1327 }
1328
1329 // Set Vertex Table if Gamut Compression is enabled
1330 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::AddVeboxVertexTable(pVeboxGamutParams->ColorSpace);
1331 }
1332
1333 // Initialize the Gamut_Expansion_Gamma_Correction.
1334 *pVeboxGEGammaCorrection = VeboxGEGammaCorrection;
1335 if (pVeboxGamutParams->GExpMode != MHW_GAMUT_MODE_NONE &&
1336 pVeboxGamutParams->GExpMode != MHW_GAMUT_MODE_CUSTOMIZED)
1337 {
1338 // Need to convert YUV input to RGB before GE
1339 pIecpState->CscState.DW0.TransformEnable = true;
1340 if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT601 ||
1341 pVeboxGamutParams->ColorSpace == MHW_CSpace_xvYCC601 ||
1342 pVeboxGamutParams->ColorSpace == MHW_CSpace_BT601_FullRange)
1343 {
1344 pIecpState->CscState.DW0.C0 = 1192;
1345 pIecpState->CscState.DW1.C1 = MOS_BITFIELD_VALUE((uint32_t)-2, 19);
1346 pIecpState->CscState.DW2.C2 = 1634;
1347 pIecpState->CscState.DW3.C3 = 1192;
1348 pIecpState->CscState.DW4.C4 = MOS_BITFIELD_VALUE((uint32_t)-401, 19);
1349 pIecpState->CscState.DW5.C5 = MOS_BITFIELD_VALUE((uint32_t)-833, 19);
1350 pIecpState->CscState.DW6.C6 = 1192;
1351 pIecpState->CscState.DW7.C7 = 2066;
1352 pIecpState->CscState.DW8.C8 = MOS_BITFIELD_VALUE((uint32_t)-1, 19);
1353 pIecpState->CscState.DW9.OffsetIn1 = MOS_BITFIELD_VALUE((uint32_t)-64, 16);
1354 pIecpState->CscState.DW9.OffsetOut1 = 0;
1355 pIecpState->CscState.DW10.OffsetIn2 = MOS_BITFIELD_VALUE((uint32_t)-512, 16);
1356 pIecpState->CscState.DW10.OffsetOut2 = 0;
1357 pIecpState->CscState.DW11.OffsetIn3 = MOS_BITFIELD_VALUE((uint32_t)-512, 16);
1358 pIecpState->CscState.DW11.OffsetOut3 = 0;
1359 }
1360 else if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT709 ||
1361 pVeboxGamutParams->ColorSpace == MHW_CSpace_xvYCC709 ||
1362 pVeboxGamutParams->ColorSpace == MHW_CSpace_BT709_FullRange)
1363 {
1364 pIecpState->CscState.DW0.C0 = 1192;
1365 pIecpState->CscState.DW1.C1 = MOS_BITFIELD_VALUE((uint32_t)-1, 19);
1366 pIecpState->CscState.DW2.C2 = 1835;
1367 pIecpState->CscState.DW3.C3 = 1192;
1368 pIecpState->CscState.DW4.C4 = MOS_BITFIELD_VALUE((uint32_t)-218, 19);
1369 pIecpState->CscState.DW5.C5 = MOS_BITFIELD_VALUE((uint32_t)-537, 19);
1370 pIecpState->CscState.DW6.C6 = 1192;
1371 pIecpState->CscState.DW7.C7 = 2164;
1372 pIecpState->CscState.DW8.C8 = 1;
1373 pIecpState->CscState.DW9.OffsetIn1 = MOS_BITFIELD_VALUE((uint32_t)-64, 16);
1374 pIecpState->CscState.DW9.OffsetOut1 = 0;
1375 pIecpState->CscState.DW10.OffsetIn2 = MOS_BITFIELD_VALUE((uint32_t)-512, 16);
1376 pIecpState->CscState.DW10.OffsetOut2 = 0;
1377 pIecpState->CscState.DW11.OffsetIn3 = MOS_BITFIELD_VALUE((uint32_t)-512, 16);
1378 pIecpState->CscState.DW11.OffsetOut3 = 0;
1379 }
1380 else
1381 {
1382 MHW_ASSERTMESSAGE("Unknown primary");
1383 }
1384
1385 if (pVeboxGamutParams->GExpMode == MHW_GAMUT_MODE_BASIC)
1386 {
1387 pGamutState->DW0.GlobalModeEnable = true;
1388 pGamutState->DW1.CmW = 1023;
1389 }
1390 else if (pVeboxGamutParams->GExpMode == MHW_GAMUT_MODE_ADVANCED)
1391 {
1392 pGamutState->DW0.GlobalModeEnable = false;
1393 }
1394
1395 pGamutState->DW1.C0 = pVeboxGamutParams->Matrix[0][0];
1396 pGamutState->DW0.C1 = pVeboxGamutParams->Matrix[0][1];
1397 pGamutState->DW3.C2 = pVeboxGamutParams->Matrix[0][2];
1398 pGamutState->DW2.C3 = pVeboxGamutParams->Matrix[1][0];
1399 pGamutState->DW5.C4 = pVeboxGamutParams->Matrix[1][1];
1400 pGamutState->DW4.C5 = pVeboxGamutParams->Matrix[1][2];
1401 pGamutState->DW7.C6 = pVeboxGamutParams->Matrix[2][0];
1402 pGamutState->DW6.C7 = pVeboxGamutParams->Matrix[2][1];
1403 pGamutState->DW8.C8 = pVeboxGamutParams->Matrix[2][2];
1404 }
1405 else if (pVeboxGamutParams->GExpMode == MHW_GAMUT_MODE_CUSTOMIZED)
1406 {
1407 pGamutState->DW0.GlobalModeEnable = true;
1408 pGamutState->DW1.CmW = 1023;
1409
1410 // Need to convert YUV input to RGB before GE
1411 // BSD only: Do this only if color space is not RGB
1412 if (pVeboxGamutParams->ColorSpace == MHW_CSpace_sRGB ||
1413 pVeboxGamutParams->ColorSpace == MHW_CSpace_stRGB ||
1414 pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020_RGB ||
1415 pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020_stRGB)
1416 {
1417 pIecpState->CscState.DW0.TransformEnable = false;
1418 }
1419 else
1420 {
1421 pIecpState->CscState.DW0.TransformEnable = true;
1422
1423 if (pVeboxIecpParams &&
1424 pVeboxIecpParams->pfCscCoeff &&
1425 pVeboxIecpParams->pfCscInOffset &&
1426 pVeboxIecpParams->pfCscOutOffset)
1427 {
1428 // BSD only; switch the first and third row to output ARGB instead of ABGR
1429 pIecpState->CscState.DW0.C0 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[0] * 65536.0F);
1430 pIecpState->CscState.DW1.C1 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[1] * 65536.0F);
1431 pIecpState->CscState.DW2.C2 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[2] * 65536.0F);
1432 pIecpState->CscState.DW3.C3 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[3] * 65536.0F);
1433 pIecpState->CscState.DW4.C4 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[4] * 65536.0F);
1434 pIecpState->CscState.DW5.C5 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[5] * 65536.0F);
1435 pIecpState->CscState.DW6.C6 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[6] * 65536.0F);
1436 pIecpState->CscState.DW7.C7 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[7] * 65536.0F);
1437 pIecpState->CscState.DW8.C8 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscCoeff[8] * 65536.0F);
1438 pIecpState->CscState.DW9.OffsetIn1 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscInOffset[0] * 128.0F);
1439 pIecpState->CscState.DW9.OffsetOut1 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscOutOffset[0] * 128.0F);
1440 pIecpState->CscState.DW10.OffsetIn2 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscInOffset[1] * 128.0F);
1441 pIecpState->CscState.DW10.OffsetOut2 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscOutOffset[1] * 128.0F);
1442 pIecpState->CscState.DW11.OffsetIn3 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscInOffset[2] * 128.0F);
1443 pIecpState->CscState.DW11.OffsetOut3 = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfCscOutOffset[2] * 128.0F);
1444
1445 if (pVeboxIecpParams->pfFeCscCoeff &&
1446 pVeboxIecpParams->pfFeCscInOffset &&
1447 pVeboxIecpParams->pfFeCscOutOffset)
1448 {
1449 pIecpState->FrontEndCsc.DW0.FrontEndCscTransformEnable = true;
1450
1451 pIecpState->FrontEndCsc.DW0.FecscC0TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[0] * 65536.0F);
1452 pIecpState->FrontEndCsc.DW1.FecscC1TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[1] * 65536.0F);
1453 pIecpState->FrontEndCsc.DW2.FecscC2TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[2] * 65536.0F);
1454 pIecpState->FrontEndCsc.DW3.FecscC3TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[3] * 65536.0F);
1455 pIecpState->FrontEndCsc.DW4.FecscC4TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[4] * 65536.0F);
1456 pIecpState->FrontEndCsc.DW5.FecscC5TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[5] * 65536.0F);
1457 pIecpState->FrontEndCsc.DW6.FecscC6TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[6] * 65536.0F);
1458 pIecpState->FrontEndCsc.DW7.FecscC7TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[7] * 65536.0F);
1459 pIecpState->FrontEndCsc.DW8.FecscC8TransformCoefficient = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscCoeff[8] * 65536.0F);
1460 pIecpState->FrontEndCsc.DW9.FecScOffsetIn1OffsetInForYR = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscInOffset[0] * 128.0F);
1461 pIecpState->FrontEndCsc.DW9.FecScOffsetOut1OffsetOutForYR = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscOutOffset[0] * 128.0F);
1462 pIecpState->FrontEndCsc.DW10.FecScOffsetIn2OffsetOutForUG = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscInOffset[1] * 128.0F);
1463 pIecpState->FrontEndCsc.DW10.FecScOffsetOut2OffsetOutForUG = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscOutOffset[1] * 128.0F);
1464 pIecpState->FrontEndCsc.DW11.FecScOffsetIn3OffsetOutForVB = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscInOffset[2] * 128.0F);
1465 pIecpState->FrontEndCsc.DW11.FecScOffsetOut3OffsetOutForVB = (uint32_t)MOS_F_ROUND(pVeboxIecpParams->pfFeCscOutOffset[2] * 128.0F);
1466 }
1467 }
1468 else
1469 {
1470 pIecpState->CscState.DW0.C0 = 76309;
1471 pIecpState->CscState.DW1.C1 = 0;
1472 pIecpState->CscState.DW2.C2 = 104597;
1473 pIecpState->CscState.DW3.C3 = 76309;
1474 pIecpState->CscState.DW4.C4 = MOS_BITFIELD_VALUE((uint32_t)-25675, 19);
1475 pIecpState->CscState.DW5.C5 = MOS_BITFIELD_VALUE((uint32_t)-53279, 19);
1476 pIecpState->CscState.DW6.C6 = 76309;
1477 pIecpState->CscState.DW7.C7 = 132201;
1478 pIecpState->CscState.DW8.C8 = 0;
1479 pIecpState->CscState.DW9.OffsetIn1 = MOS_BITFIELD_VALUE((uint32_t)-2048, 16);
1480 pIecpState->CscState.DW9.OffsetOut1 = 0;
1481 pIecpState->CscState.DW10.OffsetIn2 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
1482 pIecpState->CscState.DW10.OffsetOut2 = 0;
1483 pIecpState->CscState.DW11.OffsetIn3 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
1484 pIecpState->CscState.DW11.OffsetOut3 = 0;
1485 }
1486 }
1487
1488 pGamutState->DW1.C0 = pVeboxGamutParams->Matrix[0][0];
1489 pGamutState->DW0.C1 = pVeboxGamutParams->Matrix[0][1];
1490 pGamutState->DW3.C2 = pVeboxGamutParams->Matrix[0][2];
1491 pGamutState->DW2.C3 = pVeboxGamutParams->Matrix[1][0];
1492 pGamutState->DW5.C4 = pVeboxGamutParams->Matrix[1][1];
1493 pGamutState->DW4.C5 = pVeboxGamutParams->Matrix[1][2];
1494 pGamutState->DW7.C6 = pVeboxGamutParams->Matrix[2][0];
1495 pGamutState->DW6.C7 = pVeboxGamutParams->Matrix[2][1];
1496 pGamutState->DW8.C8 = pVeboxGamutParams->Matrix[2][2];
1497
1498 // BSD only; zero out transform output offsets
1499 pGamutState->DW9.OffsetInR = 0;
1500 pGamutState->DW10.OffsetInG = 0;
1501 pGamutState->DW11.OffsetInB = 0;
1502 pGamutState->DW12.OffsetOutR = 0;
1503 pGamutState->DW13.OffsetOutG = 0;
1504 pGamutState->DW14.OffsetOutB = 0;
1505
1506 // BSD only; set inv and fwd gamma variables
1507 if (pVeboxGamutParams->pInvGammaBias && pVeboxGamutParams->pFwdGammaBias)
1508 {
1509 for (i = 0; i < 255; i++)
1510 {
1511 usGE_Values[i][0] = 256 * i;
1512 usGE_Values[i][1] =
1513 usGE_Values[i][2] =
1514 usGE_Values[i][3] = (uint16_t)pVeboxGamutParams->pInvGammaBias[i];
1515
1516 usGE_Values[i][4] = 256 * i;
1517 usGE_Values[i][5] =
1518 usGE_Values[i][6] =
1519 usGE_Values[i][7] = (uint16_t)pVeboxGamutParams->pFwdGammaBias[i];;
1520 }
1521 // Copy two UINT16 to one DW (UNT32).
1522 MOS_SecureMemcpy(pVeboxGEGammaCorrection, sizeof(uint32_t) * 1020, usGE_Values, sizeof(uint16_t) * 8 * 255);
1523 }
1524 }
1525 else if (pVeboxGamutParams->bGammaCorr)
1526 {
1527 // Need to convert YUV input to RGB before Gamma Correction
1528 pIecpState->CscState.DW0.TransformEnable = true;
1529 if (IS_RGB_SWAP(pVeboxGamutParams->dstFormat))
1530 {
1531 pIecpState->CscState.DW0.YuvChannelSwap = true;
1532 }
1533 if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT601 ||
1534 pVeboxGamutParams->ColorSpace == MHW_CSpace_xvYCC601 ||
1535 pVeboxGamutParams->ColorSpace == MHW_CSpace_BT601_FullRange)
1536 {
1537 pIecpState->CscState.DW0.C0 = 76309;
1538 pIecpState->CscState.DW1.C1 = 0;
1539 pIecpState->CscState.DW2.C2 = 104597;
1540 pIecpState->CscState.DW3.C3 = 76309;
1541 pIecpState->CscState.DW4.C4 = MOS_BITFIELD_VALUE((uint32_t)-25675, 19);
1542 pIecpState->CscState.DW5.C5 = MOS_BITFIELD_VALUE((uint32_t)-53279, 19);
1543 pIecpState->CscState.DW6.C6 = 76309;
1544 pIecpState->CscState.DW7.C7 = 132201;
1545 pIecpState->CscState.DW8.C8 = 0;
1546 pIecpState->CscState.DW9.OffsetIn1 = MOS_BITFIELD_VALUE((uint32_t)-2048, 16);
1547 pIecpState->CscState.DW9.OffsetOut1 = 0;
1548 pIecpState->CscState.DW10.OffsetIn2 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
1549 pIecpState->CscState.DW10.OffsetOut2 = 0;
1550 pIecpState->CscState.DW11.OffsetIn3 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
1551 pIecpState->CscState.DW11.OffsetOut3 = 0;
1552 }
1553 else if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT709 ||
1554 pVeboxGamutParams->ColorSpace == MHW_CSpace_xvYCC709 ||
1555 pVeboxGamutParams->ColorSpace == MHW_CSpace_BT709_FullRange)
1556 {
1557 pIecpState->CscState.DW0.C0 = 76309;
1558 pIecpState->CscState.DW1.C1 = 0;
1559 pIecpState->CscState.DW2.C2 = 117489;
1560 pIecpState->CscState.DW3.C3 = 76309;
1561 pIecpState->CscState.DW4.C4 = MOS_BITFIELD_VALUE((uint32_t)-13975, 19);
1562 pIecpState->CscState.DW5.C5 = MOS_BITFIELD_VALUE((uint32_t)-34925, 19);
1563 pIecpState->CscState.DW6.C6 = 76309;
1564 pIecpState->CscState.DW7.C7 = 138438;
1565 pIecpState->CscState.DW8.C8 = 0;
1566 pIecpState->CscState.DW9.OffsetIn1 = MOS_BITFIELD_VALUE((uint32_t)-2048, 16);
1567 pIecpState->CscState.DW9.OffsetOut1 = 0;
1568 pIecpState->CscState.DW10.OffsetIn2 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
1569 pIecpState->CscState.DW10.OffsetOut2 = 0;
1570 pIecpState->CscState.DW11.OffsetIn3 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
1571 pIecpState->CscState.DW11.OffsetOut3 = 0;
1572 }
1573 else if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020)
1574 {
1575 VeboxInterface_BT2020YUVToRGB(m_veboxHeap, pVeboxIecpParams, pVeboxGamutParams);
1576 }
1577 else
1578 {
1579 MHW_ASSERTMESSAGE("Unknown primary");
1580 }
1581
1582 // CCM is needed for CSC(BT2020->BT709/BT601 or vice versa with Different Gamma).
1583 bEnableCCM = (pVeboxGamutParams->InputGammaValue == pVeboxGamutParams->OutputGammaValue) ? false : true;
1584 pGamutState->DW0.GlobalModeEnable = true;
1585 pGamutState->DW1.CmW = 1023;
1586 if ((pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020) && bEnableCCM)
1587 {
1588 if (pVeboxGamutParams->dstColorSpace == MHW_CSpace_BT709)
1589 {
1590 pGamutState->DW1.C0 = 108190;
1591 pGamutState->DW0.C1 = MOS_BITFIELD_VALUE((uint32_t)-38288, 21);
1592 pGamutState->DW3.C2 = MOS_BITFIELD_VALUE((uint32_t)-4747, 21);
1593 pGamutState->DW2.C3 = MOS_BITFIELD_VALUE((uint32_t)-7967, 21);
1594 pGamutState->DW5.C4 = 74174;
1595 pGamutState->DW4.C5 = MOS_BITFIELD_VALUE((uint32_t)-557, 21);
1596 pGamutState->DW7.C6 = MOS_BITFIELD_VALUE((uint32_t)-1198, 21);
1597 pGamutState->DW6.C7 = MOS_BITFIELD_VALUE((uint32_t)-6587, 21);
1598 pGamutState->DW8.C8 = 73321;
1599 }
1600 else
1601 {
1602 pGamutState->DW1.C0 = 116420;
1603 pGamutState->DW0.C1 = MOS_BITFIELD_VALUE((uint32_t)-45094, 21);
1604 pGamutState->DW3.C2 = MOS_BITFIELD_VALUE((uint32_t)-5785, 21);
1605 pGamutState->DW2.C3 = MOS_BITFIELD_VALUE((uint32_t)-10586, 21);
1606 pGamutState->DW5.C4 = 77814;
1607 pGamutState->DW4.C5 = MOS_BITFIELD_VALUE((uint32_t)-1705, 21);
1608 pGamutState->DW7.C6 = MOS_BITFIELD_VALUE((uint32_t)-1036, 21);
1609 pGamutState->DW6.C7 = MOS_BITFIELD_VALUE((uint32_t)-6284, 21);
1610 pGamutState->DW8.C8 = 72864;
1611 }
1612 }
1613 else
1614 {
1615 pGamutState->DW1.C0 = 65536;
1616 pGamutState->DW0.C1 = 0;
1617 pGamutState->DW3.C2 = 0;
1618 pGamutState->DW2.C3 = 0;
1619 pGamutState->DW5.C4 = 65536;
1620 pGamutState->DW4.C5 = 0;
1621 pGamutState->DW7.C6 = 0;
1622 pGamutState->DW6.C7 = 0;
1623 pGamutState->DW8.C8 = 65536;
1624 pGamutState->DW9.OffsetInR = 0;
1625 pGamutState->DW10.OffsetInG = 0;
1626 pGamutState->DW11.OffsetInB = 0;
1627 pGamutState->DW12.OffsetOutR = 0;
1628 pGamutState->DW13.OffsetOutG = 0;
1629 pGamutState->DW14.OffsetOutB = 0;
1630 }
1631
1632 if (pVeboxGamutParams->InputGammaValue == MHW_GAMMA_1P0)
1633 {
1634 dInverseGamma = 1.0;
1635 }
1636 else if (pVeboxGamutParams->InputGammaValue == MHW_GAMMA_2P2)
1637 {
1638 dInverseGamma = 2.2;
1639 }
1640 else if (pVeboxGamutParams->InputGammaValue == MHW_GAMMA_2P6)
1641 {
1642 dInverseGamma = 2.6;
1643 }
1644
1645 if (pVeboxGamutParams->OutputGammaValue == MHW_GAMMA_1P0)
1646 {
1647 dForwardGamma = 1.0;
1648 }
1649 else if (pVeboxGamutParams->OutputGammaValue == MHW_GAMMA_2P2)
1650 {
1651 dForwardGamma = 2.2;
1652 }
1653 else if (pVeboxGamutParams->OutputGammaValue == MHW_GAMMA_2P6)
1654 {
1655 dForwardGamma = 2.6;
1656 }
1657
1658 for (i = 0; i < 255; i++)
1659 {
1660 usGE_Values[i][0] = 256 * i;
1661 usGE_Values[i][1] =
1662 usGE_Values[i][2] =
1663 usGE_Values[i][3] = (uint16_t)MOS_F_ROUND(pow((double)((double)i / 256), dInverseGamma) * 65536);
1664
1665 usGE_Values[i][4] = 256 * i;
1666 usGE_Values[i][5] =
1667 usGE_Values[i][6] =
1668 usGE_Values[i][7] = (uint16_t)MOS_F_ROUND(pow((double)((double)i / 256), 1 / dForwardGamma) * 65536);
1669 }
1670 // Copy two uint16_t to one DW (UNT32).
1671 MOS_SecureMemcpy(pVeboxGEGammaCorrection, sizeof(uint32_t) * 1020, usGE_Values, sizeof(uint16_t) * 8 * 255);
1672 }
1673 else if (pVeboxGamutParams->bH2S)
1674 {
1675 VeboxInterface_H2SManualMode(m_veboxHeap, pVeboxIecpParams, pVeboxGamutParams);
1676 }
1677 else if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020 ||
1678 pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020_FullRange) // BT2020 CSC case
1679 {
1680 // Gamut Expansion setting
1681 pGamutState->DW0.GlobalModeEnable = true;
1682 pGamutState->DW1.CmW = 1023; // Colorimetric accurate image
1683
1684 if (pVeboxGamutParams->dstColorSpace == MHW_CSpace_BT601)
1685 {
1686 pGamutState->DW1.C0 = 116420;
1687 pGamutState->DW0.C1 = MOS_BITFIELD_VALUE((uint32_t)-45094, 21);
1688 pGamutState->DW3.C2 = MOS_BITFIELD_VALUE((uint32_t)-5785, 21);
1689 pGamutState->DW2.C3 = MOS_BITFIELD_VALUE((uint32_t)-10586, 21);
1690 pGamutState->DW5.C4 = 77814;
1691 pGamutState->DW4.C5 = MOS_BITFIELD_VALUE((uint32_t)-1705, 21);
1692 pGamutState->DW7.C6 = MOS_BITFIELD_VALUE((uint32_t)-1036, 21);
1693 pGamutState->DW6.C7 = MOS_BITFIELD_VALUE((uint32_t)-6284, 21);
1694 pGamutState->DW8.C8 = 72864;
1695 }
1696 else //BT709, sRGB has same chromaticity CIE 1931
1697 {
1698 pGamutState->DW1.C0 = 108190;
1699 pGamutState->DW0.C1 = MOS_BITFIELD_VALUE((uint32_t)-38288, 21);
1700 pGamutState->DW3.C2 = MOS_BITFIELD_VALUE((uint32_t)-4747, 21);
1701 pGamutState->DW2.C3 = MOS_BITFIELD_VALUE((uint32_t)-7967, 21);
1702 pGamutState->DW5.C4 = 74174;
1703 pGamutState->DW4.C5 = MOS_BITFIELD_VALUE((uint32_t)-557, 21);
1704 pGamutState->DW7.C6 = MOS_BITFIELD_VALUE((uint32_t)-1198, 21);
1705 pGamutState->DW6.C7 = MOS_BITFIELD_VALUE((uint32_t)-6587, 21);
1706 pGamutState->DW8.C8 = 73321;
1707 }
1708
1709 for (i = 0; i < 256; i++)
1710 {
1711 usGE_Values[i][0] = (uint16_t)m_BT2020InvPixelValue[i];
1712 usGE_Values[i][1] =
1713 usGE_Values[i][2] =
1714 usGE_Values[i][3] = (uint16_t)m_BT2020InvGammaLUT[i];
1715
1716 usGE_Values[i][4] = (uint16_t)m_BT2020FwdPixelValue[i];
1717 usGE_Values[i][5] =
1718 usGE_Values[i][6] =
1719 usGE_Values[i][7] = (uint16_t)m_BT2020FwdGammaLUT[i];
1720 }
1721 // Copy two UNT16 to one DW(UNT32).
1722 MOS_SecureMemcpy(pVeboxGEGammaCorrection, sizeof(uint32_t) * 1024, usGE_Values, sizeof(uint16_t) * 8 * 256);
1723 // Back end CSC setting, need to convert BT2020 YUV input to RGB before GE
1724 VeboxInterface_BT2020YUVToRGB(m_veboxHeap, pVeboxIecpParams, pVeboxGamutParams);
1725 }
1726 else if (pVeboxIecpParams && pVeboxIecpParams->s1DLutParams.bActive)
1727 {
1728 uint16_t in_val = 0, vchan1_y = 0, vchan2_u = 0, vchan3_v = 0;
1729 uint32_t nIndex = 0;
1730 uint16_t* pForwardGamma = (uint16_t*)pVeboxIecpParams->s1DLutParams.p1DLUT;
1731 MHW_CHK_NULL(pForwardGamma);
1732
1733 // Gamut Expansion setting
1734 pGamutState->DW0.GlobalModeEnable = true;
1735 pGamutState->DW1.CmW = 1023;
1736 dInverseGamma = 1.0;
1737
1738 for (uint32_t i = 0; i < pVeboxIecpParams->s1DLutParams.LUTSize; i++)
1739 {
1740 usGE_Values[i][0] = 257 * i;
1741 usGE_Values[i][1] =
1742 usGE_Values[i][2] =
1743 usGE_Values[i][3] = 257 * i;
1744
1745 nIndex = 4 * i;
1746 in_val = pForwardGamma[nIndex];
1747 vchan1_y = pForwardGamma[nIndex + 1];
1748 vchan2_u = pForwardGamma[nIndex + 2];
1749 vchan3_v = pForwardGamma[nIndex + 3];
1750
1751 // ayuv: in_val, vchan1_y, vchan2_u, vchan3_v
1752 usGE_Values[i][4] = (i == 0) ? 0 : ((i == 255) ? 0xffff: in_val);
1753 usGE_Values[i][5] = vchan1_y;
1754 usGE_Values[i][6] = vchan2_u;
1755 usGE_Values[i][7] = vchan3_v;
1756 }
1757 pGamutState->DW1.C0 = 65536;
1758 pGamutState->DW0.C1 = 0;
1759 pGamutState->DW3.C2 = 0;
1760 pGamutState->DW2.C3 = 0;
1761 pGamutState->DW5.C4 = 65536;
1762 pGamutState->DW4.C5 = 0;
1763 pGamutState->DW7.C6 = 0;
1764 pGamutState->DW6.C7 = 0;
1765 pGamutState->DW8.C8 = 65536;
1766 pGamutState->DW9.OffsetInR = 0;
1767 pGamutState->DW10.OffsetInG = 0;
1768 pGamutState->DW11.OffsetInB = 0;
1769 pGamutState->DW12.OffsetOutR = 0;
1770 pGamutState->DW13.OffsetOutG = 0;
1771 pGamutState->DW14.OffsetOutB = 0;
1772 // Copy two uint16_t to one DW (UNT32).
1773 MOS_SecureMemcpy(pVeboxGEGammaCorrection, sizeof(uint32_t) * 1024, usGE_Values, sizeof(uint16_t) * 8 * 256);
1774 }
1775 else
1776 {
1777 MHW_ASSERTMESSAGE("Unknown branch!");
1778 }
1779
1780 finish:
1781 return eStatus;
1782 }
1783
FindVeboxGpuNodeToUse(PMHW_VEBOX_GPUNODE_LIMIT pGpuNodeLimit)1784 MOS_STATUS MhwVeboxInterfaceG11::FindVeboxGpuNodeToUse(
1785 PMHW_VEBOX_GPUNODE_LIMIT pGpuNodeLimit)
1786 {
1787 PMOS_INTERFACE pOsInterface;
1788 MOS_GPU_NODE VeboxGpuNode = MOS_GPU_NODE_VE;
1789 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1790
1791 MHW_CHK_NULL(m_osInterface);
1792 MHW_CHK_NULL(pGpuNodeLimit);
1793
1794 pOsInterface = m_osInterface;
1795
1796 // KMD Virtual Engine, use virtual GPU NODE-- MOS_GPU_NODE_VE
1797 pGpuNodeLimit->dwGpuNodeToUse = VeboxGpuNode;
1798
1799 #if (_DEBUG || _RELEASE_INTERNAL)
1800 if (m_osInterface != nullptr && m_osInterface->bEnableDbgOvrdInVE && !m_veboxScalabilitySupported)
1801 {
1802 eStatus = MOS_STATUS_INVALID_PARAMETER;
1803 MHW_ASSERTMESSAGE("not support DebugOverride on current OS or Platform.");
1804 goto finish;
1805 }
1806
1807 if ((m_osInterface != nullptr && m_osInterface->bEnableDbgOvrdInVE) ||
1808 Mos_Solo_IsInUse(pOsInterface))
1809 {
1810 MHW_CHK_STATUS(ValidateVeboxScalabilityConfig());
1811 }
1812 #endif
1813
1814 #if !EMUL
1815 Mos_Solo_CheckNodeLimitation(pOsInterface, &pGpuNodeLimit->dwGpuNodeToUse);
1816 #endif
1817
1818 finish:
1819 return eStatus;
1820 }
1821
AddVeboxScalarState(PMHW_VEBOX_SCALAR_PARAMS pVeboxScalarParams)1822 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxScalarState(
1823 PMHW_VEBOX_SCALAR_PARAMS pVeboxScalarParams)
1824 {
1825 PMHW_VEBOX_HEAP pVeboxHeap;
1826 uint32_t uiOffset;
1827 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1828
1829 mhw_vebox_g11_X::VEBOX_Scalar_State_CMD *pVeboxScalarState, ScalarState;
1830
1831 #define SET_COEFS(UVChCoef, ScalarParam_UVChCoef) \
1832 { \
1833 UVChCoef.DW0.FilterCoefficient0 = ScalarParam_UVChCoef.FilterCoefficient0; \
1834 UVChCoef.DW0.FilterCoefficient1 = ScalarParam_UVChCoef.FilterCoefficient1; \
1835 UVChCoef.DW0.FilterCoefficient2 = ScalarParam_UVChCoef.FilterCoefficient2; \
1836 UVChCoef.DW0.FilterCoefficient3 = ScalarParam_UVChCoef.FilterCoefficient3; \
1837 UVChCoef.DW1.FilterCoefficient4 = ScalarParam_UVChCoef.FilterCoefficient4; \
1838 UVChCoef.DW1.FilterCoefficient5 = ScalarParam_UVChCoef.FilterCoefficient5; \
1839 UVChCoef.DW1.FilterCoefficient6 = ScalarParam_UVChCoef.FilterCoefficient6; \
1840 UVChCoef.DW1.FilterCoefficient7 = ScalarParam_UVChCoef.FilterCoefficient7; \
1841 }
1842
1843 MHW_CHK_NULL(pVeboxScalarParams);
1844 MHW_CHK_NULL(m_veboxHeap);
1845
1846 pVeboxHeap = m_veboxHeap;
1847 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
1848 pVeboxScalarState =
1849 (mhw_vebox_g11_X::VEBOX_Scalar_State_CMD *)(pVeboxHeap->pLockedDriverResourceMem +
1850 pVeboxHeap->uiDndiStateOffset +
1851 uiOffset);
1852 MHW_CHK_NULL(pVeboxScalarState);
1853 *pVeboxScalarState = ScalarState;
1854
1855 // Initialize the values to default for media driver.
1856 pVeboxScalarState->TableYChXDirFilterCoefficient070.DW0.FilterCoefficient3 = 64;
1857 pVeboxScalarState->TableYChYDirFilterCoefficient070.DW0.FilterCoefficient3 = 64;
1858
1859 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW0.FilterCoefficient0 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1860 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW0.FilterCoefficient1 = 7;
1861 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-13, 8);
1862 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW0.FilterCoefficient3 = 41;
1863 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW1.FilterCoefficient4 = 43;
1864 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-13, 8);
1865 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW1.FilterCoefficient6 = 7;
1866 pVeboxScalarState->TableYChXDirFilterCoefficient170.DW1.FilterCoefficient7 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1867
1868 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW0.FilterCoefficient0 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1869 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW0.FilterCoefficient1 = 7;
1870 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-13, 8);
1871 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW0.FilterCoefficient3 = 41;
1872 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW1.FilterCoefficient4 = 43;
1873 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-13, 8);
1874 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW1.FilterCoefficient6 = 7;
1875 pVeboxScalarState->TableYChYDirFilterCoefficient170.DW1.FilterCoefficient7 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1876
1877 pVeboxScalarState->TableUvChXDirFilterCoefficient070.DW0.FilterCoefficient3 = 64;
1878 pVeboxScalarState->TableUvChYDirFilterCoefficient070.DW0.FilterCoefficient3 = 64;
1879
1880 pVeboxScalarState->TableUvChXDirFilterCoefficient170.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-5, 8);
1881 pVeboxScalarState->TableUvChXDirFilterCoefficient170.DW0.FilterCoefficient3 = 55;
1882 pVeboxScalarState->TableUvChXDirFilterCoefficient170.DW1.FilterCoefficient4 = 15;
1883 pVeboxScalarState->TableUvChXDirFilterCoefficient170.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-1, 8);
1884 pVeboxScalarState->TableUvChYDirFilterCoefficient170.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-5, 8);
1885 pVeboxScalarState->TableUvChYDirFilterCoefficient170.DW0.FilterCoefficient3 = 55;
1886 pVeboxScalarState->TableUvChYDirFilterCoefficient170.DW1.FilterCoefficient4 = 15;
1887 pVeboxScalarState->TableUvChYDirFilterCoefficient170.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-1, 8);
1888
1889 pVeboxScalarState->TableUvChXDirFilterCoefficient270.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1890 pVeboxScalarState->TableUvChXDirFilterCoefficient270.DW0.FilterCoefficient3 = 36;
1891 pVeboxScalarState->TableUvChXDirFilterCoefficient270.DW1.FilterCoefficient4 = 36;
1892 pVeboxScalarState->TableUvChXDirFilterCoefficient270.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1893 pVeboxScalarState->TableUvChYDirFilterCoefficient270.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1894 pVeboxScalarState->TableUvChYDirFilterCoefficient270.DW0.FilterCoefficient3 = 36;
1895 pVeboxScalarState->TableUvChYDirFilterCoefficient270.DW1.FilterCoefficient4 = 36;
1896 pVeboxScalarState->TableUvChYDirFilterCoefficient270.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-4, 8);
1897
1898 pVeboxScalarState->TableUvChXDirFilterCoefficient370.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-1, 8);
1899 pVeboxScalarState->TableUvChXDirFilterCoefficient370.DW0.FilterCoefficient3 = 15;
1900 pVeboxScalarState->TableUvChXDirFilterCoefficient370.DW1.FilterCoefficient4 = 55;
1901 pVeboxScalarState->TableUvChXDirFilterCoefficient370.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-5, 8);
1902 pVeboxScalarState->TableUvChYDirFilterCoefficient370.DW0.FilterCoefficient2 = MOS_BITFIELD_VALUE((uint32_t)-1, 8);
1903 pVeboxScalarState->TableUvChYDirFilterCoefficient370.DW0.FilterCoefficient3 = 15;
1904 pVeboxScalarState->TableUvChYDirFilterCoefficient370.DW1.FilterCoefficient4 = 55;
1905 pVeboxScalarState->TableUvChYDirFilterCoefficient370.DW1.FilterCoefficient5 = MOS_BITFIELD_VALUE((uint32_t)-5, 8);
1906
1907 pVeboxScalarState->DW26.DisableChromaChannelDiagonalInterpolation =
1908 pVeboxScalarParams->bDisableChromaChannelDiagonalInterpolation;
1909
1910 if (!pVeboxScalarParams->bDisableChromaChannelDiagonalInterpolation)
1911 {
1912 SET_COEFS(pVeboxScalarState->TableUvChXDirFilterCoefficient070,
1913 pVeboxScalarParams->UVChCoefficient0);
1914 SET_COEFS(pVeboxScalarState->TableUvChYDirFilterCoefficient070,
1915 pVeboxScalarParams->UVChCoefficient0);
1916
1917 SET_COEFS(pVeboxScalarState->TableUvChXDirFilterCoefficient170,
1918 pVeboxScalarParams->UVChCoefficient1);
1919 SET_COEFS(pVeboxScalarState->TableUvChYDirFilterCoefficient170,
1920 pVeboxScalarParams->UVChCoefficient1);
1921
1922 SET_COEFS(pVeboxScalarState->TableUvChXDirFilterCoefficient270,
1923 pVeboxScalarParams->UVChCoefficient2);
1924 SET_COEFS(pVeboxScalarState->TableUvChYDirFilterCoefficient270,
1925 pVeboxScalarParams->UVChCoefficient2);
1926
1927 SET_COEFS(pVeboxScalarState->TableUvChXDirFilterCoefficient370,
1928 pVeboxScalarParams->UVChCoefficient3);
1929 SET_COEFS(pVeboxScalarState->TableUvChYDirFilterCoefficient370,
1930 pVeboxScalarParams->UVChCoefficient3);
1931 }
1932
1933 pVeboxScalarState->DW28.SadWt0 = pVeboxScalarParams->dwSADWT0;
1934 pVeboxScalarState->DW28.SadWt1 = pVeboxScalarParams->dwSADWT1;
1935 pVeboxScalarState->DW28.SadWt2 = pVeboxScalarParams->dwSADWT2;
1936 pVeboxScalarState->DW28.SadWt3 = pVeboxScalarParams->dwSADWT3;
1937 pVeboxScalarState->DW29.SadWt4 = pVeboxScalarParams->dwSADWT4;
1938 pVeboxScalarState->DW29.SadWt5 = pVeboxScalarParams->dwSADWT5;
1939
1940 #undef SET_COEFS
1941 finish:
1942 return eStatus;
1943 }
1944
AddVeboxDndiState(PMHW_VEBOX_DNDI_PARAMS pVeboxDndiParams)1945 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxDndiState(
1946 PMHW_VEBOX_DNDI_PARAMS pVeboxDndiParams)
1947 {
1948 PMHW_VEBOX_HEAP pVeboxHeap;
1949 uint32_t uiOffset;
1950 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1951
1952 mhw_vebox_g11_X::VEBOX_DNDI_STATE_CMD *pVeboxDndiState, mVeboxDndiState;
1953
1954 MHW_CHK_NULL(pVeboxDndiParams);
1955 MHW_CHK_NULL(m_veboxHeap);
1956
1957 pVeboxHeap = m_veboxHeap;
1958 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
1959 pVeboxDndiState =
1960 (mhw_vebox_g11_X::VEBOX_DNDI_STATE_CMD *)(pVeboxHeap->pLockedDriverResourceMem +
1961 pVeboxHeap->uiDndiStateOffset +
1962 uiOffset);
1963 MHW_CHK_NULL(pVeboxDndiState);
1964 *pVeboxDndiState = mVeboxDndiState;
1965
1966 pVeboxDndiState->DW0.DenoiseMaximumHistory = pVeboxDndiParams->dwDenoiseMaximumHistory;
1967 pVeboxDndiState->DW0.DenoiseStadThreshold = pVeboxDndiParams->dwDenoiseSTADThreshold;
1968 pVeboxDndiState->DW1.DenoiseAsdThreshold = pVeboxDndiParams->dwDenoiseASDThreshold;
1969 pVeboxDndiState->DW1.DenoiseHistoryIncrease = pVeboxDndiParams->dwDenoiseHistoryDelta;
1970 pVeboxDndiState->DW1.DenoiseMovingPixelThreshold = pVeboxDndiParams->dwDenoiseMPThreshold;
1971 pVeboxDndiState->DW2.TemporalDifferenceThreshold = pVeboxDndiParams->dwTDThreshold;
1972 pVeboxDndiState->DW3.LowTemporalDifferenceThreshold = pVeboxDndiParams->dwLTDThreshold;
1973 pVeboxDndiState->DW3.ProgressiveDn = pVeboxDndiParams->bProgressiveDN;
1974 pVeboxDndiState->DW3.HotPixelCountLuma = pVeboxDndiParams->dwHotPixelCount;
1975 pVeboxDndiState->DW4.DenoiseThresholdForSumOfComplexityMeasureLuma = pVeboxDndiParams->dwDenoiseSCMThreshold;
1976 pVeboxDndiState->DW4.HotPixelThresholdLuma = pVeboxDndiParams->dwHotPixelThreshold;
1977 pVeboxDndiState->DW5.ChromaDenoiseStadThreshold = pVeboxDndiParams->dwChromaSTADThreshold;
1978 pVeboxDndiState->DW5.HotPixelCountChromaU = m_chromaParams.dwHotPixelCountChromaU;
1979 pVeboxDndiState->DW5.HotPixelThresholdChromaU = m_chromaParams.dwHotPixelThresholdChromaU;
1980 pVeboxDndiState->DW6.ChromaDenoiseEnable = pVeboxDndiParams->bChromaDNEnable;
1981 pVeboxDndiState->DW6.ChromaTemporalDifferenceThreshold = pVeboxDndiParams->dwChromaTDThreshold;
1982 pVeboxDndiState->DW7.ChromaLowTemporalDifferenceThreshold = pVeboxDndiParams->dwChromaLTDThreshold;
1983 pVeboxDndiState->DW7.HotPixelCountChromaV = m_chromaParams.dwHotPixelCountChromaV;
1984 pVeboxDndiState->DW7.HotPixelThresholdChromaV = m_chromaParams.dwHotPixelThresholdChromaV;
1985 pVeboxDndiState->DW8.ChromaDenoiseMovingPixelThreshold = m_chromaParams.dwHotPixelThresholdChromaV;
1986
1987 pVeboxDndiState->DW9.DnyWr040 = pVeboxDndiParams->dwPixRangeWeight[0];
1988 pVeboxDndiState->DW9.DnyWr140 = pVeboxDndiParams->dwPixRangeWeight[1];
1989 pVeboxDndiState->DW9.DnyWr240 = pVeboxDndiParams->dwPixRangeWeight[2];
1990 pVeboxDndiState->DW9.DnyWr340 = pVeboxDndiParams->dwPixRangeWeight[3];
1991 pVeboxDndiState->DW9.DnyWr440 = pVeboxDndiParams->dwPixRangeWeight[4];
1992 pVeboxDndiState->DW9.DnyWr540 = pVeboxDndiParams->dwPixRangeWeight[5];
1993
1994 pVeboxDndiState->DW11.DnyPrt5120 = pVeboxDndiParams->dwPixRangeThreshold[5];
1995 pVeboxDndiState->DW12.DnyPrt4120 = pVeboxDndiParams->dwPixRangeThreshold[4];
1996 pVeboxDndiState->DW12.DnyPrt3120 = pVeboxDndiParams->dwPixRangeThreshold[3];
1997 pVeboxDndiState->DW13.DnyPrt2120 = pVeboxDndiParams->dwPixRangeThreshold[2];
1998 pVeboxDndiState->DW13.DnyPrt1120 = pVeboxDndiParams->dwPixRangeThreshold[1];
1999 pVeboxDndiState->DW14.DnyPrt0120 = pVeboxDndiParams->dwPixRangeThreshold[0];
2000
2001 pVeboxDndiState->DW16.DnuWr040 = m_chromaParams.dwPixRangeWeightChromaU[0];
2002 pVeboxDndiState->DW16.DnuWr140 = m_chromaParams.dwPixRangeWeightChromaU[1];
2003 pVeboxDndiState->DW16.DnuWr240 = m_chromaParams.dwPixRangeWeightChromaU[2];
2004 pVeboxDndiState->DW16.DnuWr340 = m_chromaParams.dwPixRangeWeightChromaU[3];
2005 pVeboxDndiState->DW16.DnuWr440 = m_chromaParams.dwPixRangeWeightChromaU[4];
2006 pVeboxDndiState->DW16.DnuWr540 = m_chromaParams.dwPixRangeWeightChromaU[5];
2007
2008 pVeboxDndiState->DW18.DnuPrt5120 = m_chromaParams.dwPixRangeThresholdChromaU[5];
2009 pVeboxDndiState->DW19.DnuPrt4120 = m_chromaParams.dwPixRangeThresholdChromaU[4];
2010 pVeboxDndiState->DW19.DnuPrt3120 = m_chromaParams.dwPixRangeThresholdChromaU[3];
2011 pVeboxDndiState->DW20.DnuPrt2120 = m_chromaParams.dwPixRangeThresholdChromaU[2];
2012 pVeboxDndiState->DW20.DnuPrt1120 = m_chromaParams.dwPixRangeThresholdChromaU[1];
2013 pVeboxDndiState->DW21.DnuPrt0120 = m_chromaParams.dwPixRangeThresholdChromaU[0];
2014
2015 pVeboxDndiState->DW23.DnvWr040 = m_chromaParams.dwPixRangeWeightChromaV[0];
2016 pVeboxDndiState->DW23.DnvWr5140 = m_chromaParams.dwPixRangeWeightChromaV[1];
2017 pVeboxDndiState->DW23.DnvWr240 = m_chromaParams.dwPixRangeWeightChromaV[2];
2018 pVeboxDndiState->DW23.DnvWr340 = m_chromaParams.dwPixRangeWeightChromaV[3];
2019 pVeboxDndiState->DW23.DnvWr440 = m_chromaParams.dwPixRangeWeightChromaV[4];
2020 pVeboxDndiState->DW23.DnvWr540 = m_chromaParams.dwPixRangeWeightChromaV[5];
2021
2022 pVeboxDndiState->DW25.DnvPrt5120 = m_chromaParams.dwPixRangeThresholdChromaV[5];
2023 pVeboxDndiState->DW26.DnvPrt4120 = m_chromaParams.dwPixRangeThresholdChromaV[4];
2024 pVeboxDndiState->DW26.DnvPrt3120 = m_chromaParams.dwPixRangeThresholdChromaV[3];
2025 pVeboxDndiState->DW27.DnvPrt2120 = m_chromaParams.dwPixRangeThresholdChromaV[2];
2026 pVeboxDndiState->DW27.DnvPrt1120 = m_chromaParams.dwPixRangeThresholdChromaV[1];
2027 pVeboxDndiState->DW28.DnvPrt0120 = m_chromaParams.dwPixRangeThresholdChromaV[0];
2028
2029 pVeboxDndiState->DW38.DnDiTopFirst = pVeboxDndiParams->bDNDITopFirst;
2030
2031 pVeboxDndiState->DW39.ProgressiveCadenceReconstructionFor1StFieldOfCurrentFrame = pVeboxDndiParams->dwFMDFirstFieldCurrFrame;
2032 pVeboxDndiState->DW39.ProgressiveCadenceReconstructionFor2NdFieldOfPreviousFrame = pVeboxDndiParams->dwFMDSecondFieldPrevFrame;
2033
2034 // Improved Deinterlacing
2035 pVeboxDndiState->DW36.LumatdmWt = pVeboxDndiParams->dwLumaTDMWeight;
2036 pVeboxDndiState->DW36.ChromatdmWt = pVeboxDndiParams->dwChromaTDMWeight;
2037
2038 pVeboxDndiState->DW37.CoringThresholdForSvcm = pVeboxDndiParams->dwSVCMThreshold;
2039 pVeboxDndiState->DW37.DeltabitValueForSvcm = pVeboxDndiParams->dwSVCMDelta;
2040 pVeboxDndiState->DW37.CoringThresholdForShcm = pVeboxDndiParams->dwSHCMThreshold;
2041 pVeboxDndiState->DW37.DeltabitValueForShcm = pVeboxDndiParams->dwSHCMDelta;
2042
2043 pVeboxDndiState->DW39.ChromaSmallerWindowForTdm = pVeboxDndiParams->bTDMChromaSmallerWindow;
2044 pVeboxDndiState->DW39.LumaSmallerWindowForTdm = pVeboxDndiParams->bTDMLumaSmallerWindow;
2045 pVeboxDndiState->DW39.Fastercovergence = pVeboxDndiParams->bFasterConvergence;
2046
2047 pVeboxDndiState->DW40.SadWt0 = pVeboxDndiParams->dwSADWT0;
2048 pVeboxDndiState->DW40.SadWt1 = pVeboxDndiParams->dwSADWT1;
2049 pVeboxDndiState->DW40.SadWt2 = pVeboxDndiParams->dwSADWT2;
2050 pVeboxDndiState->DW40.SadWt3 = pVeboxDndiParams->dwSADWT3;
2051 pVeboxDndiState->DW41.SadWt4 = pVeboxDndiParams->dwSADWT4;
2052 pVeboxDndiState->DW41.SadWt6 = pVeboxDndiParams->dwSADWT6;
2053
2054 pVeboxDndiState->DW41.CoringThresholdForLumaSadCalculation = pVeboxDndiParams->dwLumaTDMCoringThreshold;
2055 pVeboxDndiState->DW41.CoringThresholdForChromaSadCalculation = pVeboxDndiParams->dwChromaTDMCoringThreshold;
2056
2057 pVeboxDndiState->DW42.ParDiffcheckslackthreshold = pVeboxDndiParams->dwDiffCheckSlackThreshold;
2058 pVeboxDndiState->DW42.ParTearinghighthreshold = pVeboxDndiParams->dwTearingHighThreshold;
2059 pVeboxDndiState->DW42.ParTearinglowthreshold = pVeboxDndiParams->dwTearingLowThreshold;
2060 pVeboxDndiState->DW42.ParDirectioncheckth = pVeboxDndiParams->dwDirectionCheckThreshold;
2061 pVeboxDndiState->DW42.ParSyntheticcontentcheck = pVeboxDndiParams->bSyntheticContentCheck;
2062 pVeboxDndiState->DW42.ParLocalcheck = pVeboxDndiParams->bLocalCheck;
2063 pVeboxDndiState->DW42.ParUsesyntheticcontentmedian = pVeboxDndiParams->bUseSyntheticContentMedian;
2064 pVeboxDndiState->DW42.BypassDeflicker = pVeboxDndiParams->bBypassDeflickerFilter;
2065
2066 pVeboxDndiState->DW43.Lpfwtlut0 = pVeboxDndiParams->dwLPFWtLUT0;
2067 pVeboxDndiState->DW43.Lpfwtlut1 = pVeboxDndiParams->dwLPFWtLUT1;
2068 pVeboxDndiState->DW43.Lpfwtlut2 = pVeboxDndiParams->dwLPFWtLUT2;
2069 pVeboxDndiState->DW43.Lpfwtlut3 = pVeboxDndiParams->dwLPFWtLUT3;
2070 pVeboxDndiState->DW44.Lpfwtlut4 = pVeboxDndiParams->dwLPFWtLUT4;
2071 pVeboxDndiState->DW44.Lpfwtlut5 = pVeboxDndiParams->dwLPFWtLUT5;
2072 pVeboxDndiState->DW44.Lpfwtlut6 = pVeboxDndiParams->dwLPFWtLUT6;
2073 pVeboxDndiState->DW44.Lpfwtlut7 = pVeboxDndiParams->dwLPFWtLUT7;
2074
2075 pVeboxDndiState->DW10.DnyThmin120 = 512;
2076 pVeboxDndiState->DW10.DnyThmax120 = 2048;
2077 pVeboxDndiState->DW11.DnyDynThmin120 = 256;
2078
2079 pVeboxDndiState->DW14.DnyWd2040 = 10;
2080 pVeboxDndiState->DW14.DnyWd2140 = 10;
2081 pVeboxDndiState->DW14.DnyWd2240 = 8;
2082 pVeboxDndiState->DW15.DnyWd0040 = 12;
2083 pVeboxDndiState->DW15.DnyWd0140 = 12;
2084 pVeboxDndiState->DW15.DnyWd0240 = 10;
2085 pVeboxDndiState->DW15.DnyWd1040 = 12;
2086 pVeboxDndiState->DW15.DnyWd1140 = 11;
2087 pVeboxDndiState->DW15.DnyWd1240 = 10;
2088
2089 pVeboxDndiState->DW17.DnuThmin120 = 512;
2090 pVeboxDndiState->DW17.DnuThmax120 = 2048;
2091 pVeboxDndiState->DW18.DnuDynThmin120 = 256;
2092
2093 pVeboxDndiState->DW21.DnuWd2040 = 10;
2094 pVeboxDndiState->DW21.DnuWd2140 = 10;
2095 pVeboxDndiState->DW21.DnuWd2240 = 8;
2096 pVeboxDndiState->DW22.DnuWd0040 = 12;
2097 pVeboxDndiState->DW22.DnuWd0140 = 12;
2098 pVeboxDndiState->DW22.DnuWd0240 = 10;
2099 pVeboxDndiState->DW22.DnuWd1040 = 12;
2100 pVeboxDndiState->DW22.DnuWd1140 = 11;
2101 pVeboxDndiState->DW22.DnuWd1240 = 10;
2102
2103 pVeboxDndiState->DW24.DnvThmin120 = 512;
2104 pVeboxDndiState->DW24.DnvThmax120 = 2048;
2105 pVeboxDndiState->DW25.DnvDynThmin120 = 256;
2106
2107 pVeboxDndiState->DW28.DnvWd2040 = 10;
2108 pVeboxDndiState->DW28.DnvWd2140 = 10;
2109 pVeboxDndiState->DW28.DnvWd2240 = 8;
2110 pVeboxDndiState->DW29.DnvWd0040 = 12;
2111 pVeboxDndiState->DW29.DnvWd0140 = 12;
2112 pVeboxDndiState->DW29.DnvWd0240 = 10;
2113 pVeboxDndiState->DW29.DnvWd1040 = 12;
2114 pVeboxDndiState->DW29.DnvWd1140 = 11;
2115 pVeboxDndiState->DW29.DnvWd1240 = 10;
2116
2117 pVeboxDndiState->DW31.SmallSobelCountThreshold = 6;
2118 pVeboxDndiState->DW32.LargeSobelCountThreshold = 6;
2119 pVeboxDndiState->DW32.MedianSobelCountThreshold = 40;
2120
2121 pVeboxDndiState->DW34.StmmC2 = 2;
2122 pVeboxDndiState->DW35.MaximumStmm = 150;
2123 pVeboxDndiState->DW35.MultiplierForVecm = 30;
2124 pVeboxDndiState->DW35.BlendingConstantAcrossTimeForSmallValuesOfStmm = 125;
2125 pVeboxDndiState->DW35.BlendingConstantAcrossTimeForLargeValuesOfStmm = 64;
2126
2127 pVeboxDndiState->DW36.FmdTemporalDifferenceThreshold = 175;
2128 pVeboxDndiState->DW36.StmmOutputShift = 5;
2129 pVeboxDndiState->DW36.StmmShiftUp = 1;
2130 pVeboxDndiState->DW36.MinimumStmm = 118;
2131
2132 pVeboxDndiState->DW38.McdiEnable = 1;
2133 pVeboxDndiState->DW38.FmdTearThreshold = 2;
2134 pVeboxDndiState->DW38.Fmd2VerticalDifferenceThreshold = 100;
2135 pVeboxDndiState->DW38.Fmd1VerticalDifferenceThreshold = 16;
2136
2137 finish:
2138 return eStatus;
2139 }
2140
AddVeboxIecpState(PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams)2141 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxIecpState(
2142 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams)
2143 {
2144 bool bEnableFECSC = false;
2145 PMHW_FORWARD_GAMMA_SEG pFwdGammaSeg;
2146 uint8_t *p3DLUT;
2147 PMHW_VEBOX_HEAP pVeboxHeap;
2148 uint32_t uiOffset;
2149 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2150
2151 mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *pVeboxIecpState;
2152
2153 MHW_CHK_NULL(pVeboxIecpParams);
2154 MHW_CHK_NULL(m_veboxHeap);
2155
2156 pVeboxHeap = m_veboxHeap;
2157 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
2158 pVeboxIecpState = (mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *)(pVeboxHeap->pLockedDriverResourceMem +
2159 pVeboxHeap->uiIecpStateOffset +
2160 uiOffset);
2161 MHW_CHK_NULL(pVeboxIecpState);
2162 IecpStateInitialization(pVeboxIecpState);
2163
2164 if (pVeboxIecpParams->ColorPipeParams.bActive)
2165 {
2166 // Enable STD/E (Skin Tone Detection/Enhancement)
2167 SetVeboxIecpStateSTE(
2168 &pVeboxIecpState->StdSteState,
2169 &pVeboxIecpParams->ColorPipeParams);
2170
2171 // Enable TCC (Total Color Control)
2172 if (pVeboxIecpParams->ColorPipeParams.bEnableTCC)
2173 {
2174 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::SetVeboxIecpStateTCC(
2175 &pVeboxIecpState->TccState,
2176 &pVeboxIecpParams->ColorPipeParams);
2177 }
2178 }
2179
2180 // Enable ACE (Automatic Contrast Enhancement). Enable LACE if it's enabled.
2181 if (pVeboxIecpParams->bAce ||
2182 (pVeboxIecpParams->ColorPipeParams.bActive &&
2183 pVeboxIecpParams->ColorPipeParams.bEnableACE))
2184 {
2185 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::SetVeboxIecpStateACELACE(
2186 &pVeboxIecpState->AceState,
2187 &pVeboxIecpState->AlphaAoiState,
2188 (pVeboxIecpParams->ColorPipeParams.bEnableLACE == true) ? true : false);
2189 }
2190
2191 if (pVeboxIecpParams->CapPipeParams.bActive)
2192 {
2193 // IECP needs to operate in YUV space
2194 if ((pVeboxIecpParams->srcFormat != Format_AYUV) &&
2195 (pVeboxIecpParams->dstFormat == Format_AYUV ||
2196 pVeboxIecpParams->dstFormat == Format_Y416 ||
2197 pVeboxIecpParams->ProcAmpParams.bActive ||
2198 pVeboxIecpParams->ColorPipeParams.bActive))
2199 {
2200 bEnableFECSC = true;
2201 }
2202 else if (pVeboxIecpParams->CapPipeParams.FECSCParams.bActive)
2203 {
2204 bEnableFECSC = true;
2205 }
2206 else
2207 {
2208 bEnableFECSC = false;
2209 }
2210
2211 // Enable Front End CSC so that input to IECP will be in YUV color space
2212 if (bEnableFECSC)
2213 {
2214 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::SetVeboxIecpStateFecsc(&pVeboxIecpState->FrontEndCsc, pVeboxIecpParams);
2215 }
2216
2217 // Enable Color Correction Matrix
2218 if (pVeboxIecpParams->CapPipeParams.ColorCorrectionParams.bActive)
2219 {
2220 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::SetVeboxIecpStateCcm(
2221 pVeboxIecpState,
2222 &pVeboxIecpParams->CapPipeParams,
2223 65536);
2224 }
2225 }
2226
2227 // Enable Back End CSC for capture pipeline or Vebox output pipe
2228 if (pVeboxIecpParams->CapPipeParams.bActive ||
2229 pVeboxIecpParams->bCSCEnable)
2230 {
2231 SetVeboxIecpStateBecsc(
2232 pVeboxIecpState,
2233 pVeboxIecpParams,
2234 bEnableFECSC);
2235 }
2236
2237 // Enable ProcAmp
2238 if (pVeboxIecpParams->ProcAmpParams.bActive &&
2239 pVeboxIecpParams->ProcAmpParams.bEnabled)
2240 {
2241 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::SetVeboxIecpStateProcAmp(
2242 &pVeboxIecpState->ProcampState,
2243 &pVeboxIecpParams->ProcAmpParams);
2244 }
2245
2246 if (pVeboxIecpParams && pVeboxIecpParams->CapPipeParams.bActive)
2247 {
2248 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::AddVeboxCapPipeState(
2249 &pVeboxIecpParams->CapPipeParams);
2250 }
2251
2252 if (pVeboxIecpParams &&
2253 pVeboxIecpParams->CapPipeParams.bActive &&
2254 pVeboxIecpParams->CapPipeParams.FwdGammaParams.bActive)
2255 {
2256 pFwdGammaSeg =
2257 (PMHW_FORWARD_GAMMA_SEG)(pVeboxHeap->pLockedDriverResourceMem +
2258 pVeboxHeap->uiGammaCorrectionStateOffset +
2259 uiOffset);
2260
2261 MHW_CHK_NULL(pFwdGammaSeg);
2262
2263 MOS_SecureMemcpy(
2264 pFwdGammaSeg,
2265 sizeof(MHW_FORWARD_GAMMA_SEG) * MHW_FORWARD_GAMMA_SEGMENT_CONTROL_POINT,
2266 &pVeboxIecpParams->CapPipeParams.FwdGammaParams.Segment[0],
2267 sizeof(MHW_FORWARD_GAMMA_SEG) * MHW_FORWARD_GAMMA_SEGMENT_CONTROL_POINT);
2268 }
2269
2270 finish:
2271 return eStatus;
2272 }
2273
AddVeboxIecpAceState(PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams)2274 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxIecpAceState(
2275 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams)
2276 {
2277 PMHW_ACE_PARAMS pAceParams;
2278 PMHW_LACE_PARAMS pLaceParams;
2279 PMHW_VEBOX_HEAP pVeboxHeap;
2280 int32_t uiOffset;
2281 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2282
2283 mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *pVeboxIecpState;
2284
2285 MHW_CHK_NULL(pVeboxIecpParams);
2286 MHW_CHK_NULL(m_veboxHeap);
2287
2288 pVeboxHeap = m_veboxHeap;
2289 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
2290
2291 pVeboxIecpState = (mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *)(pVeboxHeap->pLockedDriverResourceMem +
2292 pVeboxHeap->uiIecpStateOffset +
2293 uiOffset);
2294 MHW_CHK_NULL(pVeboxIecpState);
2295
2296 MhwVeboxInterfaceGeneric<mhw_vebox_g11_X>::SetVeboxAceLaceState(pVeboxIecpParams, pVeboxIecpState);
2297
2298 if (pVeboxIecpParams->ColorPipeParams.bActive &&
2299 pVeboxIecpParams->ColorPipeParams.bEnableLACE)
2300 {
2301 pLaceParams = &pVeboxIecpParams->ColorPipeParams.LaceParams;
2302
2303 pVeboxIecpState->AceState.DW0.MinAceLuma = pLaceParams->wMinAceLuma;
2304 pVeboxIecpState->AceState.DW12.MaxAceLuma = pLaceParams->wMaxAceLuma;
2305 }
2306
2307 finish:
2308 return eStatus;
2309 }
2310
2311 #if (_DEBUG || _RELEASE_INTERNAL)
ValidateVeboxScalabilityConfig()2312 MOS_STATUS MhwVeboxInterfaceG11::ValidateVeboxScalabilityConfig()
2313 {
2314 MEDIA_SYSTEM_INFO *pGtSystemInfo;
2315 MOS_FORCE_VEBOX eForceVebox;
2316 bool bScalableVEMode;
2317 bool bUseVE1, bUseVE2;
2318 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2319
2320 MHW_CHK_NULL(m_osInterface);
2321
2322 eForceVebox = m_osInterface->eForceVebox;
2323 bScalableVEMode = ((m_osInterface->bVeboxScalabilityMode) ? true : false);
2324 pGtSystemInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
2325 MHW_CHK_NULL(pGtSystemInfo);
2326
2327 if (eForceVebox != MOS_FORCE_VEBOX_NONE &&
2328 eForceVebox != MOS_FORCE_VEBOX_1 &&
2329 eForceVebox != MOS_FORCE_VEBOX_2 &&
2330 eForceVebox != MOS_FORCE_VEBOX_1_2)
2331 {
2332 eStatus = MOS_STATUS_INVALID_PARAMETER;
2333 MHW_ASSERTMESSAGE("eForceVebox value is invalid.");
2334 goto finish;
2335 }
2336
2337 if (!bScalableVEMode &&
2338 (eForceVebox == MOS_FORCE_VEBOX_1_2))
2339 {
2340 eStatus = MOS_STATUS_INVALID_PARAMETER;
2341 MHW_ASSERTMESSAGE("eForceVebox value is not consistent with scalability mode.");
2342 goto finish;
2343 }
2344
2345 if (bScalableVEMode && !m_veboxScalabilitySupported)
2346 {
2347 eStatus = MOS_STATUS_INVALID_PARAMETER;
2348 MHW_ASSERTMESSAGE("scalability mode is not allowed on current platform!");
2349 goto finish;
2350 }
2351
2352 bUseVE1 = bUseVE2 = false;
2353 if (eForceVebox == MOS_FORCE_VEBOX_NONE)
2354 {
2355 bUseVE1 = true;
2356 }
2357 else
2358 {
2359 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_1, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE1);
2360 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_2, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE2);
2361 }
2362
2363 if (!pGtSystemInfo->VEBoxInfo.IsValid ||
2364 (bUseVE1 && !pGtSystemInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled) ||
2365 (bUseVE2 && !pGtSystemInfo->VEBoxInfo.Instances.Bits.VEBox1Enabled))
2366 {
2367 eStatus = MOS_STATUS_INVALID_PARAMETER;
2368 MHW_ASSERTMESSAGE("the forced VEBOX is not enabled in current platform.");
2369 goto finish;
2370 }
2371
2372 finish:
2373 return eStatus;
2374 }
2375 #endif
2376
SetVeboxInUse(bool inputVebox0,bool inputVebox1)2377 MOS_STATUS MhwVeboxInterfaceG11::SetVeboxInUse(
2378 bool inputVebox0,
2379 bool inputVebox1)
2380 {
2381 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2382
2383 m_vebox0InUse = inputVebox0;
2384 m_vebox1InUse = inputVebox1;
2385
2386 return eStatus;
2387 }
2388
IsScalabilitySupported()2389 bool MhwVeboxInterfaceG11::IsScalabilitySupported()
2390 {
2391 return m_veboxScalabilitySupported;
2392 }
2393
VeboxInterface_BT2020YUVToRGB(PMHW_VEBOX_HEAP pVeboxHeapInput,PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,PMHW_VEBOX_GAMUT_PARAMS pVeboxGamutParams)2394 MOS_STATUS MhwVeboxInterfaceG11::VeboxInterface_BT2020YUVToRGB(
2395 PMHW_VEBOX_HEAP pVeboxHeapInput,
2396 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,
2397 PMHW_VEBOX_GAMUT_PARAMS pVeboxGamutParams)
2398 {
2399 mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *pIecpState;
2400 PMHW_VEBOX_HEAP pVeboxHeap;
2401 uint32_t uiOffset;
2402 MOS_STATUS eStatus = MOS_STATUS_NULL_POINTER;
2403
2404 MHW_CHK_NULL(pVeboxHeapInput);
2405
2406 MOS_UNUSED(pVeboxIecpParams);
2407 MOS_UNUSED(pVeboxGamutParams);
2408
2409 pVeboxHeap = pVeboxHeapInput;
2410 MHW_CHK_NULL(pVeboxHeap);
2411
2412 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
2413 pIecpState = (mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *)(pVeboxHeap->pLockedDriverResourceMem + pVeboxHeap->uiIecpStateOffset + uiOffset);
2414
2415 MHW_CHK_NULL(pIecpState);
2416
2417 pIecpState->CscState.DW0.TransformEnable = true;
2418
2419 if (IS_RGB_SWAP(pVeboxGamutParams->dstFormat))
2420 {
2421 pIecpState->CscState.DW0.YuvChannelSwap = true;
2422 }
2423
2424 if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020) // Limited->Full
2425 {
2426 pIecpState->CscState.DW0.C0 = 76607;
2427 pIecpState->CscState.DW1.C1 = 0;
2428 pIecpState->CscState.DW2.C2 = 110443;
2429 pIecpState->CscState.DW3.C3 = 76607;
2430 pIecpState->CscState.DW4.C4 = MOS_BITFIELD_VALUE((uint32_t)-12325, 19);
2431 pIecpState->CscState.DW5.C5 = MOS_BITFIELD_VALUE((uint32_t)-42793, 19);
2432 pIecpState->CscState.DW6.C6 = 76607;
2433 pIecpState->CscState.DW7.C7 = 140911;
2434 pIecpState->CscState.DW8.C8 = 0;
2435
2436 pIecpState->CscState.DW9.OffsetIn1 = MOS_BITFIELD_VALUE((uint32_t)-2048, 16);
2437 pIecpState->CscState.DW10.OffsetIn2 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
2438 pIecpState->CscState.DW11.OffsetIn3 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
2439
2440 pIecpState->CscState.DW9.OffsetOut1 = 0;
2441 pIecpState->CscState.DW10.OffsetOut2 = 0;
2442 pIecpState->CscState.DW11.OffsetOut3 = 0;
2443 }
2444 else if (pVeboxGamutParams->ColorSpace == MHW_CSpace_BT2020_FullRange) // Full->Full
2445 {
2446 pIecpState->CscState.DW0.C0 = 65536;
2447 pIecpState->CscState.DW1.C1 = 0;
2448 pIecpState->CscState.DW2.C2 = 96639;
2449 pIecpState->CscState.DW3.C3 = 65536;
2450 pIecpState->CscState.DW4.C4 = MOS_BITFIELD_VALUE((uint32_t)-10784, 19);
2451 pIecpState->CscState.DW5.C5 = MOS_BITFIELD_VALUE((uint32_t)-37444, 19);
2452 pIecpState->CscState.DW6.C6 = 65536;
2453 pIecpState->CscState.DW7.C7 = 123299;
2454 pIecpState->CscState.DW8.C8 = 0;
2455
2456 pIecpState->CscState.DW9.OffsetIn1 = 0;
2457 pIecpState->CscState.DW10.OffsetIn2 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
2458 pIecpState->CscState.DW11.OffsetIn3 = MOS_BITFIELD_VALUE((uint32_t)-16384, 16);
2459
2460 pIecpState->CscState.DW9.OffsetOut1 = 0;
2461 pIecpState->CscState.DW10.OffsetOut2 = 0;
2462 pIecpState->CscState.DW11.OffsetOut3 = 0;
2463 }
2464 else
2465 {
2466 MHW_ASSERTMESSAGE("Unsupported BeCSC input color space");
2467 }
2468
2469 eStatus = MOS_STATUS_SUCCESS;
2470
2471 finish:
2472 return eStatus;
2473 }
2474
VeboxInterface_H2SManualMode(PMHW_VEBOX_HEAP pVeboxHeapInput,PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,PMHW_VEBOX_GAMUT_PARAMS pVeboxGamutParams)2475 MOS_STATUS MhwVeboxInterfaceG11::VeboxInterface_H2SManualMode(
2476 PMHW_VEBOX_HEAP pVeboxHeapInput,
2477 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams,
2478 PMHW_VEBOX_GAMUT_PARAMS pVeboxGamutParams)
2479 {
2480 PMHW_VEBOX_HEAP pVeboxHeap;
2481 uint32_t uiOffset;
2482
2483 mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *pIecpState;
2484 mhw_vebox_g11_X::VEBOX_GAMUT_CONTROL_STATE_CMD *pGamutState;
2485 mhw_vebox_g11_X::Gamut_Expansion_Gamma_Correction_CMD *pVeboxGEGammaCorrection, VeboxGeGammaCorrection;
2486 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2487
2488 // HDR H2S algorithm related
2489 int32_t iToneMappingX[5] = { 40, 200, 1000, 2000, 4000 };
2490 int32_t iToneMappingY[4] = { 2500, 5000, 10000, 10000 };
2491 float fPivotX[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
2492 float fPivotY[4] = { 0.0, 0.0, 0.0, 0.0 };
2493 float fSlope[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
2494 float fMaxCLL = 0.0;
2495 // OETF parameters, corresponding to input
2496 uint32_t uiOETF[HDR_OETF_1DLUT_POINT_NUMBER] = { 0 };
2497 uint16_t usGE_Values[256][8] = { 0 };
2498
2499 MHW_CHK_NULL(pVeboxGamutParams);
2500 MHW_CHK_NULL(pVeboxHeapInput);
2501
2502 pVeboxHeap = pVeboxHeapInput;
2503 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
2504 pIecpState = (mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD*)(pVeboxHeap->pLockedDriverResourceMem + pVeboxHeap->uiIecpStateOffset + uiOffset);
2505 pVeboxGEGammaCorrection = (mhw_vebox_g11_X::Gamut_Expansion_Gamma_Correction_CMD *)(pVeboxHeap->pLockedDriverResourceMem
2506 + pVeboxHeap->uiGamutStateOffset + uiOffset);
2507 fMaxCLL = (65535 * (float)pVeboxGamutParams->uiMaxCLL) / 10000;
2508
2509 MHW_CHK_NULL(pIecpState);
2510 MHW_CHK_NULL(pVeboxGEGammaCorrection);
2511
2512 // Must initialize VeboxIecpState even if it is not used because GCE
2513 // requires GlobalIECP enable bit to be turned on
2514 if (!pVeboxIecpParams)
2515 {
2516 IecpStateInitialization(pIecpState);
2517 }
2518 pGamutState = &pIecpState->GamutState;
2519
2520 for (int32_t i = 0; i < 4; i++)
2521 {
2522 fPivotX[i] = (iToneMappingY[i] < 10000) ? (65535 * (float)iToneMappingX[i]) / 10000 : MOS_MIN((65535 * (float)iToneMappingX[i]) / 10000, fMaxCLL);
2523 fPivotY[i] = (65535 * (float)iToneMappingY[i]) / 10000;
2524 }
2525 fPivotX[4] = MOS_MIN((65535 * (float)iToneMappingX[4]) / 10000, fMaxCLL);
2526
2527 // Slope
2528 fSlope[0] = fPivotX[0] > 0 ? (float)(fPivotY[0] / fPivotX[0]) : 0;
2529 fPivotY[0] = fSlope[0] * fPivotX[0];
2530 for (int32_t i = 1; i < 4; i++)
2531 {
2532 fSlope[i] = (fPivotX[i] - fPivotX[i - 1]) > 0 ? (float)(fPivotY[i] - fPivotY[i - 1]) / (fPivotX[i] - fPivotX[i - 1]) : 0;
2533 fPivotY[i] = fSlope[i] * (fPivotX[i] - fPivotX[i - 1]) + fPivotY[i - 1];
2534 }
2535 fSlope[4] = (fPivotX[4] - fPivotX[3]) > 0 ? (float)(65535 - fPivotY[3]) / (fPivotX[4] - fPivotX[3]) : 0;
2536
2537 // Linear Operation
2538 for (int32_t n = 1; n < HDR_OETF_1DLUT_POINT_NUMBER; n++)
2539 {
2540 if ((float)g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n] < fSlope[0] * fPivotX[0])
2541 {
2542 uiOETF[n] = (uint32_t)((float)(g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n]) / fSlope[0]);
2543 }
2544 else if ((float)g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n] < fSlope[1] * (fPivotX[1] - fPivotX[0]) + fPivotY[0])
2545 {
2546 uiOETF[n] = (uint32_t)(((float)(g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n]) - fPivotY[0]) / fSlope[1] + fPivotX[0]);
2547 }
2548 else if ((float)g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n] < fSlope[2] * (fPivotX[2] - fPivotX[1]) + fPivotY[1])
2549 {
2550 uiOETF[n] = (uint32_t)(((float)g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n] - fPivotY[1]) / fSlope[2] + fPivotX[1]);
2551 }
2552 else if ((float)g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n] < fSlope[3] * (fPivotX[3] - fPivotX[2]) + fPivotY[2])
2553 {
2554 uiOETF[n] = (uint32_t)(((float)g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n] - fPivotY[2]) / fSlope[3] + fPivotX[2]);
2555 }
2556 else
2557 {
2558 uiOETF[n] = (uint32_t)(((float)g_Hdr_ColorCorrect_OETF_Rec709_Input_g11[n] - fPivotY[3]) / fSlope[4] + fPivotX[3]);
2559 }
2560 }
2561 uiOETF[0] = 0;
2562 uiOETF[255] = 65535;
2563
2564 // Back end CSC setting, need to convert BT2020 YUV input to RGB before GE
2565 VeboxInterface_BT2020YUVToRGB(pVeboxHeap, pVeboxIecpParams, pVeboxGamutParams);
2566
2567 // Global setting
2568 pGamutState->DW0.GlobalModeEnable = true;
2569 pGamutState->DW1.CmW = 1023; // Colorimetric accurate image
2570
2571 // CCM
2572 pGamutState->DW1.C0 = 108822;
2573 pGamutState->DW0.C1 = MOS_BITFIELD_VALUE((uint32_t)-38511, 21);
2574 pGamutState->DW3.C2 = MOS_BITFIELD_VALUE((uint32_t)-4774, 21);
2575 pGamutState->DW2.C3 = MOS_BITFIELD_VALUE((uint32_t)-8163, 21);
2576 pGamutState->DW5.C4 = 74246;
2577 pGamutState->DW4.C5 = MOS_BITFIELD_VALUE((uint32_t)-547, 21);
2578 pGamutState->DW7.C6 = MOS_BITFIELD_VALUE((uint32_t)-1190, 21);
2579 pGamutState->DW6.C7 = MOS_BITFIELD_VALUE((uint32_t)-6592, 21);
2580 pGamutState->DW8.C8 = 73317;
2581
2582 // Gamma Expansion
2583 *pVeboxGEGammaCorrection = VeboxGeGammaCorrection;
2584 for (int32_t i = 0; i < 255; i++)
2585 {
2586 usGE_Values[i][0] = g_Hdr_ColorCorrect_EOTF_SMPTE_ST2084_Input_g11[i];
2587 usGE_Values[i][1] = g_Hdr_ColorCorrect_EOTF_SMPTE_ST2084_Output_g11[i];
2588 usGE_Values[i][2] = g_Hdr_ColorCorrect_EOTF_SMPTE_ST2084_Output_g11[i];
2589 usGE_Values[i][3] = g_Hdr_ColorCorrect_EOTF_SMPTE_ST2084_Output_g11[i];
2590
2591 usGE_Values[i][4] = (uint16_t)uiOETF[i];
2592 usGE_Values[i][5] = g_Hdr_ColorCorrect_OETF_Rec709_Output_g11[i];
2593 usGE_Values[i][6] = g_Hdr_ColorCorrect_OETF_Rec709_Output_g11[i];
2594 usGE_Values[i][7] = g_Hdr_ColorCorrect_OETF_Rec709_Output_g11[i];
2595 }
2596 // Keep the last 4 DWs' value as defult 65535.See mhw_vebox_g10_X::Gamut_Expansion_Gamma_Correction_CMD();
2597 MOS_SecureMemcpy(pVeboxGEGammaCorrection, sizeof(uint32_t)* 1020, usGE_Values, sizeof(uint16_t)* 2040);
2598
2599 finish:
2600 return eStatus;
2601 }
2602
IecpStateInitialization(mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD * pVeboxIecpState)2603 void MhwVeboxInterfaceG11::IecpStateInitialization(mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD *pVeboxIecpState)
2604 {
2605 MHW_CHK_NULL_NO_STATUS_RETURN(pVeboxIecpState);
2606
2607 mhw_vebox_g11_X::VEBOX_IECP_STATE_CMD IecpState;
2608 *pVeboxIecpState = IecpState;
2609
2610 // Re-set the values
2611 pVeboxIecpState->StdSteState.DW5.InvMarginVyl = 3300;
2612 pVeboxIecpState->StdSteState.DW5.InvSkinTypesMargin = 1638;
2613 pVeboxIecpState->StdSteState.DW12.B3U = 140;
2614 pVeboxIecpState->StdSteState.DW27.Hues0Dark = 256;
2615 pVeboxIecpState->StdSteState.DW27.Hues1Dark = 0;
2616
2617 pVeboxIecpState->AceState.DW0.LaceHistogramSize = 1;
2618
2619 pVeboxIecpState->TccState.DW0.Satfactor1 = 160;
2620 pVeboxIecpState->TccState.DW0.Satfactor2 = 160;
2621 pVeboxIecpState->TccState.DW0.Satfactor3 = 160;
2622 pVeboxIecpState->TccState.DW1.Satfactor4 = 160;
2623 pVeboxIecpState->TccState.DW1.Satfactor5 = 160;
2624 pVeboxIecpState->TccState.DW1.Satfactor6 = 160;
2625
2626 pVeboxIecpState->GamutState.DW2.CmS = 640;
2627 pVeboxIecpState->GamutState.DW3.AG = 26;
2628 pVeboxIecpState->GamutState.DW4.AB = 26;
2629 pVeboxIecpState->GamutState.DW5.RS = 768;
2630 pVeboxIecpState->GamutState.DW6.CmI = 192;
2631 pVeboxIecpState->GamutState.DW7.RI = 128;
2632
2633 return;
2634 }
2635
AdjustBoundary(PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,uint32_t * pdwSurfaceWidth,uint32_t * pdwSurfaceHeight,bool bDIEnable)2636 MOS_STATUS MhwVeboxInterfaceG11::AdjustBoundary(
2637 PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,
2638 uint32_t *pdwSurfaceWidth,
2639 uint32_t *pdwSurfaceHeight,
2640 bool bDIEnable)
2641 {
2642 uint16_t wWidthAlignUnit;
2643 uint16_t wHeightAlignUnit;
2644 MEDIA_WA_TABLE *pWaTable = nullptr;
2645 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2646
2647 MHW_CHK_NULL(pSurfaceParam);
2648 MHW_CHK_NULL(pdwSurfaceWidth);
2649 MHW_CHK_NULL(pdwSurfaceHeight);
2650 MHW_CHK_NULL(m_osInterface);
2651
2652 // initialize
2653 wHeightAlignUnit = 1;
2654 wWidthAlignUnit = 1;
2655
2656 pWaTable = m_osInterface->pfnGetWaTable(m_osInterface);
2657 MHW_CHK_NULL(pWaTable);
2658
2659 switch (pSurfaceParam->Format)
2660 {
2661 case Format_NV12:
2662 wHeightAlignUnit = bDIEnable ? 4 : 2;
2663 wWidthAlignUnit = 2;
2664 break;
2665
2666 case Format_YUYV:
2667 case Format_YUY2:
2668 case Format_UYVY:
2669 case Format_YVYU:
2670 case Format_VYUY:
2671 case Format_Y210:
2672 case Format_Y216:
2673 wHeightAlignUnit = bDIEnable ? 2 : 1;
2674 wWidthAlignUnit = 2;
2675 break;
2676
2677 case Format_AYUV:
2678 case Format_Y416:
2679 wHeightAlignUnit = 1;
2680 wWidthAlignUnit = 2;
2681 break;
2682
2683 // For other formats, we will not do any special alignment
2684 case Format_A8R8G8B8:
2685 case Format_X8R8G8B8:
2686 case Format_A8B8G8R8:
2687 case Format_X8B8G8R8:
2688 case Format_L8:
2689 default:
2690 break;
2691 }
2692
2693 if (bDIEnable && m_veboxScalabilitySupported)
2694 {
2695 wWidthAlignUnit = 64;
2696 }
2697
2698 if (MEDIA_IS_WA(pWaTable, WaVeboxInputHeight16Aligned) &&
2699 (pSurfaceParam->Format == Format_NV12 ||
2700 pSurfaceParam->Format == Format_P010 ||
2701 pSurfaceParam->Format == Format_P016))
2702 {
2703 wHeightAlignUnit = 16;
2704 }
2705
2706 //When Crop being used in vebox, source surface height/width is updated in VeboxAdjustBoundary(), and the rcMaxSrc is used for crop rectangle.
2707 //But in dynamic Crop case, if the rcMaxSrc is larger than the rcSrc, the input pdwSurfaceHeight/pdwSurfaceWidth will be the input surface size.
2708 //And if the target surface size is smaller than input surface, it may lead to pagefault issue . So in Vebox Crop case, we set the pdwSurfaceHeight/pdwSurfaceWidth
2709 //with rcSrc to ensure Vebox input size is same with target Dstrec.
2710 if (pSurfaceParam->bVEBOXCroppingUsed)
2711 {
2712 *pdwSurfaceHeight = MOS_ALIGN_CEIL(
2713 MOS_MIN(pSurfaceParam->dwHeight, MOS_MAX((uint32_t)pSurfaceParam->rcSrc.bottom, MHW_VEBOX_MIN_HEIGHT)),
2714 wHeightAlignUnit);
2715 *pdwSurfaceWidth = MOS_ALIGN_CEIL(
2716 MOS_MIN(pSurfaceParam->dwWidth, MOS_MAX((uint32_t)pSurfaceParam->rcSrc.right, MHW_VEBOX_MIN_WIDTH)),
2717 wWidthAlignUnit);
2718 MHW_NORMALMESSAGE("bVEBOXCroppingUsed = true, pSurfaceParam->rcSrc.bottom: %d, pSurfaceParam->rcSrc.right: %d; pdwSurfaceHeight: %d, pdwSurfaceWidth: %d;",
2719 (uint32_t)pSurfaceParam->rcSrc.bottom,
2720 (uint32_t)pSurfaceParam->rcSrc.right,
2721 *pdwSurfaceHeight,
2722 *pdwSurfaceWidth);
2723 MT_LOG5(MT_VP_MHW_VE_ADJUST_SURFPARAM, MT_NORMAL, MT_VP_RENDER_VE_CROPPING, 1, MT_RECT_BOTTOM, pSurfaceParam->rcSrc.bottom,
2724 MT_RECT_RIGHT, pSurfaceParam->rcSrc.right, MT_SURF_HEIGHT, *pdwSurfaceHeight, MT_SURF_WIDTH, *pdwSurfaceWidth);
2725 }
2726 else
2727 {
2728 // Align width and height with max src renctange with consideration of
2729 // these conditions:
2730 // The minimum of width/height should equal to or larger than
2731 // MHW_VEBOX_MIN_WIDTH/HEIGHT. The maximum of width/heigh should equal
2732 // to or smaller than surface width/height
2733 *pdwSurfaceHeight = MOS_ALIGN_CEIL(
2734 MOS_MIN(pSurfaceParam->dwHeight, MOS_MAX((uint32_t)pSurfaceParam->rcMaxSrc.bottom, MHW_VEBOX_MIN_HEIGHT)),
2735 wHeightAlignUnit);
2736 *pdwSurfaceWidth = MOS_ALIGN_CEIL(
2737 MOS_MIN(pSurfaceParam->dwWidth, MOS_MAX((uint32_t)pSurfaceParam->rcMaxSrc.right, MHW_VEBOX_MIN_WIDTH)),
2738 wWidthAlignUnit);
2739 MHW_NORMALMESSAGE("bVEBOXCroppingUsed = false, pSurfaceParam->rcMaxSrc.bottom: %d, pSurfaceParam->rcMaxSrc.right: %d; pdwSurfaceHeight: %d, pdwSurfaceWidth: %d;",
2740 (uint32_t)pSurfaceParam->rcMaxSrc.bottom,
2741 (uint32_t)pSurfaceParam->rcMaxSrc.right,
2742 *pdwSurfaceHeight,
2743 *pdwSurfaceWidth);
2744 }
2745
2746
2747 finish:
2748 return eStatus;
2749 }
2750
AddVeboxSurfaceControlBits(PMHW_VEBOX_SURFACE_CNTL_PARAMS pVeboxSurfCntlParams,uint32_t * pSurfCtrlBits)2751 MOS_STATUS MhwVeboxInterfaceG11::AddVeboxSurfaceControlBits(
2752 PMHW_VEBOX_SURFACE_CNTL_PARAMS pVeboxSurfCntlParams,
2753 uint32_t *pSurfCtrlBits)
2754 {
2755 PLATFORM Platform = {};
2756 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2757
2758 mhw_vebox_g11_X::VEB_DI_IECP_COMMAND_SURFACE_CONTROL_BITS_CMD *pVeboxSurfCtrlBits;
2759
2760 MHW_CHK_NULL(pVeboxSurfCntlParams);
2761 MHW_CHK_NULL(pSurfCtrlBits);
2762 MHW_CHK_NULL(m_osInterface);
2763
2764 m_osInterface->pfnGetPlatform(m_osInterface, &Platform);
2765
2766 pVeboxSurfCtrlBits = (mhw_vebox_g11_X::VEB_DI_IECP_COMMAND_SURFACE_CONTROL_BITS_CMD *)pSurfCtrlBits;
2767
2768 if (pVeboxSurfCntlParams->bIsCompressed)
2769 {
2770 pVeboxSurfCtrlBits->DW0.MemoryCompressionEnable = 1;
2771
2772 if (pVeboxSurfCntlParams->CompressionMode == MOS_MMC_VERTICAL)
2773 {
2774 pVeboxSurfCtrlBits->DW0.MemoryCompressionMode = 1;
2775 }
2776 }
2777
2778 finish:
2779 return eStatus;
2780 }
2781
SetVeboxChromaParams(MHW_VEBOX_CHROMA_PARAMS * chromaParams)2782 MOS_STATUS MhwVeboxInterfaceG11::SetVeboxChromaParams(
2783 MHW_VEBOX_CHROMA_PARAMS *chromaParams)
2784 {
2785 MHW_CHK_NULL_RETURN(chromaParams);
2786 MOS_SecureMemcpy(&m_chromaParams, sizeof(MHW_VEBOX_CHROMA_PARAMS), chromaParams, sizeof(MHW_VEBOX_CHROMA_PARAMS));
2787
2788 return MOS_STATUS_SUCCESS;
2789 }
2790
2791 //!
2792 //! \brief Create Gpu Context for Vebox
2793 //! \details Create Gpu Context for Vebox
2794 //! \param [in] pOsInterface
2795 //! OS interface
2796 //! \param [in] VeboxGpuContext
2797 //! Vebox Gpu Context
2798 //! \param [in] VeboxGpuNode
2799 //! Vebox Gpu Node
2800 //! \return MOS_STATUS
2801 //! MOS_STATUS_SUCCESS if success, else fail reason
2802 //!
CreateGpuContext(PMOS_INTERFACE pOsInterface,MOS_GPU_CONTEXT VeboxGpuContext,MOS_GPU_NODE VeboxGpuNode)2803 MOS_STATUS MhwVeboxInterfaceG11::CreateGpuContext(
2804 PMOS_INTERFACE pOsInterface,
2805 MOS_GPU_CONTEXT VeboxGpuContext,
2806 MOS_GPU_NODE VeboxGpuNode)
2807 {
2808 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2809
2810 MHW_CHK_NULL(pOsInterface);
2811
2812 Mos_SetVirtualEngineSupported(pOsInterface, true);
2813 pOsInterface->pfnVirtualEngineSupported(pOsInterface, true, true);
2814
2815 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(pOsInterface))
2816 {
2817 MOS_GPUCTX_CREATOPTIONS createOption;
2818
2819 // Create VEBOX/VEBOX2 Context
2820 MHW_CHK_STATUS(pOsInterface->pfnCreateGpuContext(
2821 pOsInterface,
2822 VeboxGpuContext,
2823 VeboxGpuNode,
2824 &createOption));
2825 }
2826 else
2827 {
2828 MOS_GPUCTX_CREATOPTIONS_ENHANCED createOptionenhanced;
2829
2830 createOptionenhanced.LRCACount = 1;
2831 createOptionenhanced.UsingSFC = true;
2832
2833 // Create VEBOX/VEBOX2 Context
2834 MHW_CHK_STATUS(pOsInterface->pfnCreateGpuContext(
2835 pOsInterface,
2836 VeboxGpuContext,
2837 VeboxGpuNode,
2838 &createOptionenhanced));
2839 }
2840
2841 finish:
2842 return eStatus;
2843 }
2844