| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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) |
| 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 |
|
| 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 |
|
| 2389 |
bool MhwVeboxInterfaceG11::IsScalabilitySupported() |
| 2390 |
{ |
| 2391 |
return m_veboxScalabilitySupported; |
| 2392 |
} |
| 2393 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
//! |
| 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 |
} |