1 /* 2 * Copyright (c) 2017, 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 codechal_kernel_hme_g8.h 24 //! \brief Hme kernel implementation for Gen8 platform 25 //! 26 27 #ifndef __CODECHAL_KERNEL_HME_G8_H__ 28 #define __CODECHAL_KERNEL_HME_G8_H__ 29 #include "codechal_kernel_hme.h" 30 31 class CodechalKernelHmeG8 : public CodechalKernelHme 32 { 33 public: 34 // clang-format off 35 class Curbe 36 { 37 public: Curbe()38 Curbe() 39 { 40 MOS_SecureMemcpy(&m_data, sizeof(m_data), &m_initCurbe, sizeof(m_initCurbe)); 41 } 42 43 struct CurbeData 44 { 45 // DW0 46 union 47 { 48 struct 49 { 50 uint32_t SkipModeEn : MOS_BITFIELD_BIT(0); 51 uint32_t AdaptiveEn : MOS_BITFIELD_BIT(1); 52 uint32_t BiMixDis : MOS_BITFIELD_BIT(2); 53 uint32_t reserved3 : MOS_BITFIELD_RANGE(3, 4); 54 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT(5); 55 uint32_t reserved6 : MOS_BITFIELD_BIT(6); 56 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT(7); 57 uint32_t reserved8 : MOS_BITFIELD_RANGE(8, 23); 58 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE(24, 31); 59 }; 60 uint32_t Value; 61 } DW0; 62 63 // DW1 64 union 65 { 66 struct 67 { 68 uint32_t MaxNumMVs : MOS_BITFIELD_RANGE(0, 5); 69 uint32_t reserved6 : MOS_BITFIELD_RANGE(6, 15); 70 uint32_t BiWeight : MOS_BITFIELD_RANGE(16, 21); 71 uint32_t reserved22 : MOS_BITFIELD_RANGE(22, 27); 72 uint32_t UniMixDisable : MOS_BITFIELD_BIT(28); 73 uint32_t reserved29 : MOS_BITFIELD_RANGE(29, 31); 74 }; 75 uint32_t Value; 76 } DW1; 77 78 // DW2 79 union 80 { 81 struct 82 { 83 uint32_t MaxLenSP : MOS_BITFIELD_RANGE(0, 7); 84 uint32_t MaxNumSU : MOS_BITFIELD_RANGE(8, 15); 85 uint32_t reserved16 : MOS_BITFIELD_RANGE(16, 31); 86 }; 87 uint32_t Value; 88 } DW2; 89 90 // DW3 91 union 92 { 93 struct 94 { 95 uint32_t SrcSize : MOS_BITFIELD_RANGE(0, 1); 96 uint32_t reserved2 : MOS_BITFIELD_RANGE(2, 3); 97 uint32_t MbTypeRemap : MOS_BITFIELD_RANGE(4, 5); 98 uint32_t SrcAccess : MOS_BITFIELD_BIT(6); 99 uint32_t RefAccess : MOS_BITFIELD_BIT(7); 100 uint32_t SearchCtrl : MOS_BITFIELD_RANGE(8, 10); 101 uint32_t DualSearchPathOption : MOS_BITFIELD_BIT(11); 102 uint32_t SubPelMode : MOS_BITFIELD_RANGE(12, 13); 103 uint32_t SkipType : MOS_BITFIELD_BIT(14); 104 uint32_t DisableFieldCacheAlloc : MOS_BITFIELD_BIT(15); 105 uint32_t InterChromaMode : MOS_BITFIELD_BIT(16); 106 uint32_t FTEnable : MOS_BITFIELD_BIT(17); 107 uint32_t BMEDisableFBR : MOS_BITFIELD_BIT(18); 108 uint32_t BlockBasedSkipEnable : MOS_BITFIELD_BIT(19); 109 uint32_t InterSAD : MOS_BITFIELD_RANGE(20, 21); 110 uint32_t IntraSAD : MOS_BITFIELD_RANGE(22, 23); 111 uint32_t SubMbPartMask : MOS_BITFIELD_RANGE(24, 30); 112 uint32_t reserved31 : MOS_BITFIELD_BIT(31); 113 }; 114 uint32_t Value; 115 } DW3; 116 117 // DW4 118 union 119 { 120 struct 121 { 122 uint32_t reserved0 : MOS_BITFIELD_RANGE(0, 7); 123 uint32_t PictureHeightMinus1 : MOS_BITFIELD_RANGE(8, 15); 124 uint32_t PictureWidth : MOS_BITFIELD_RANGE(16, 23); 125 uint32_t reserved24 : MOS_BITFIELD_RANGE(24, 31); 126 }; 127 uint32_t Value; 128 } DW4; 129 130 // DW5 131 union 132 { 133 struct 134 { 135 uint32_t reserved0 : MOS_BITFIELD_RANGE(0, 7); 136 uint32_t QpPrimeY : MOS_BITFIELD_RANGE(8, 15); 137 uint32_t RefWidth : MOS_BITFIELD_RANGE(16, 23); 138 uint32_t RefHeight : MOS_BITFIELD_RANGE(24, 31); 139 }; 140 uint32_t Value; 141 } DW5; 142 143 // DW6 144 union 145 { 146 struct 147 { 148 uint32_t reserved0 : MOS_BITFIELD_RANGE(0, 2); 149 uint32_t WriteDistortions : MOS_BITFIELD_BIT(3); 150 uint32_t UseMvFromPrevStep : MOS_BITFIELD_BIT(4); 151 uint32_t reserved5 : MOS_BITFIELD_RANGE(5, 7); 152 uint32_t SuperCombineDist : MOS_BITFIELD_RANGE(8, 15); 153 uint32_t MaxVmvR : MOS_BITFIELD_RANGE(16, 31); 154 }; 155 uint32_t Value; 156 } DW6; 157 158 // DW7 159 union 160 { 161 struct 162 { 163 uint32_t reserved0 : MOS_BITFIELD_RANGE(0, 15); 164 uint32_t MVCostScaleFactor : MOS_BITFIELD_RANGE(16, 17); 165 uint32_t BilinearEnable : MOS_BITFIELD_BIT(18); 166 uint32_t SrcFieldPolarity : MOS_BITFIELD_BIT(19); 167 uint32_t WeightedSADHAAR : MOS_BITFIELD_BIT(20); 168 uint32_t AConlyHAAR : MOS_BITFIELD_BIT(21); 169 uint32_t RefIDCostMode : MOS_BITFIELD_BIT(22); 170 uint32_t reserved23 : MOS_BITFIELD_BIT(23); 171 uint32_t SkipCenterMask : MOS_BITFIELD_RANGE(24, 31); 172 }; 173 uint32_t Value; 174 } DW7; 175 176 // DW8 177 union 178 { 179 struct 180 { 181 uint32_t Mode0Cost : MOS_BITFIELD_RANGE(0, 7); 182 uint32_t Mode1Cost : MOS_BITFIELD_RANGE(8, 15); 183 uint32_t Mode2Cost : MOS_BITFIELD_RANGE(16, 23); 184 uint32_t Mode3Cost : MOS_BITFIELD_RANGE(24, 31); 185 }; 186 uint32_t Value; 187 } DW8; 188 189 // DW9 190 union 191 { 192 struct 193 { 194 uint32_t Mode4Cost : MOS_BITFIELD_RANGE(0, 7); 195 uint32_t Mode5Cost : MOS_BITFIELD_RANGE(8, 15); 196 uint32_t Mode6Cost : MOS_BITFIELD_RANGE(16, 23); 197 uint32_t Mode7Cost : MOS_BITFIELD_RANGE(24, 31); 198 }; 199 uint32_t Value; 200 } DW9; 201 202 // DW10 203 union 204 { 205 struct 206 { 207 uint32_t Mode8Cost : MOS_BITFIELD_RANGE(0, 7); 208 uint32_t Mode9Cost : MOS_BITFIELD_RANGE(8, 15); 209 uint32_t RefIDCost : MOS_BITFIELD_RANGE(16, 23); 210 uint32_t ChromaIntraModeCost : MOS_BITFIELD_RANGE(24, 31); 211 }; 212 uint32_t Value; 213 } DW10; 214 215 // DW11 216 union 217 { 218 struct 219 { 220 uint32_t MV0Cost : MOS_BITFIELD_RANGE(0, 7); 221 uint32_t MV1Cost : MOS_BITFIELD_RANGE(8, 15); 222 uint32_t MV2Cost : MOS_BITFIELD_RANGE(16, 23); 223 uint32_t MV3Cost : MOS_BITFIELD_RANGE(24, 31); 224 }; 225 uint32_t Value; 226 } DW11; 227 228 // DW12 229 union 230 { 231 struct 232 { 233 uint32_t MV4Cost : MOS_BITFIELD_RANGE(0, 7); 234 uint32_t MV5Cost : MOS_BITFIELD_RANGE(8, 15); 235 uint32_t MV6Cost : MOS_BITFIELD_RANGE(16, 23); 236 uint32_t MV7Cost : MOS_BITFIELD_RANGE(24, 31); 237 }; 238 uint32_t Value; 239 } DW12; 240 241 // DW13 242 union 243 { 244 struct 245 { 246 uint32_t NumRefIdxL0MinusOne : MOS_BITFIELD_RANGE(0, 7); 247 uint32_t NumRefIdxL1MinusOne : MOS_BITFIELD_RANGE(8, 15); 248 uint32_t ActualMBWidth : MOS_BITFIELD_RANGE(16, 23); 249 uint32_t ActualMBHeight : MOS_BITFIELD_RANGE(24, 31); 250 }; 251 uint32_t Value; 252 } DW13; 253 254 // DW14 255 union 256 { 257 struct 258 { 259 uint32_t List0RefID0FieldParity : MOS_BITFIELD_BIT(0); 260 uint32_t List0RefID1FieldParity : MOS_BITFIELD_BIT(1); 261 uint32_t List0RefID2FieldParity : MOS_BITFIELD_BIT(2); 262 uint32_t List0RefID3FieldParity : MOS_BITFIELD_BIT(3); 263 uint32_t List0RefID4FieldParity : MOS_BITFIELD_BIT(4); 264 uint32_t List0RefID5FieldParity : MOS_BITFIELD_BIT(5); 265 uint32_t List0RefID6FieldParity : MOS_BITFIELD_BIT(6); 266 uint32_t List0RefID7FieldParity : MOS_BITFIELD_BIT(7); 267 uint32_t List1RefID0FieldParity : MOS_BITFIELD_BIT(8); 268 uint32_t List1RefID1FieldParity : MOS_BITFIELD_BIT(9); 269 uint32_t reserved10 : MOS_BITFIELD_RANGE(10, 31); 270 }; 271 uint32_t Value; 272 } DW14; 273 274 // DW15 275 union 276 { 277 struct 278 { 279 uint32_t PrevMvReadPosFactor : MOS_BITFIELD_RANGE(0, 7); 280 uint32_t MvShiftFactor : MOS_BITFIELD_RANGE(8, 15); 281 uint32_t Reserved : MOS_BITFIELD_RANGE(16, 31); 282 }; 283 uint32_t Value; 284 } DW15; 285 286 struct 287 { 288 // DW16 289 union 290 { 291 struct 292 { 293 SearchPathDelta SPDelta_0; 294 SearchPathDelta SPDelta_1; 295 SearchPathDelta SPDelta_2; 296 SearchPathDelta SPDelta_3; 297 }; 298 uint32_t Value; 299 } DW16; 300 301 // DW17 302 union 303 { 304 struct 305 { 306 SearchPathDelta SPDelta_4; 307 SearchPathDelta SPDelta_5; 308 SearchPathDelta SPDelta_6; 309 SearchPathDelta SPDelta_7; 310 }; 311 uint32_t Value; 312 } DW17; 313 314 // DW18 315 union 316 { 317 struct 318 { 319 SearchPathDelta SPDelta_8; 320 SearchPathDelta SPDelta_9; 321 SearchPathDelta SPDelta_10; 322 SearchPathDelta SPDelta_11; 323 }; 324 uint32_t Value; 325 } DW18; 326 327 // DW19 328 union 329 { 330 struct 331 { 332 SearchPathDelta SPDelta_12; 333 SearchPathDelta SPDelta_13; 334 SearchPathDelta SPDelta_14; 335 SearchPathDelta SPDelta_15; 336 }; 337 uint32_t Value; 338 } DW19; 339 340 // DW20 341 union 342 { 343 struct 344 { 345 SearchPathDelta SPDelta_16; 346 SearchPathDelta SPDelta_17; 347 SearchPathDelta SPDelta_18; 348 SearchPathDelta SPDelta_19; 349 }; 350 uint32_t Value; 351 } DW20; 352 353 // DW21 354 union 355 { 356 struct 357 { 358 SearchPathDelta SPDelta_20; 359 SearchPathDelta SPDelta_21; 360 SearchPathDelta SPDelta_22; 361 SearchPathDelta SPDelta_23; 362 }; 363 uint32_t Value; 364 } DW21; 365 366 // DW22 367 union 368 { 369 struct 370 { 371 SearchPathDelta SPDelta_24; 372 SearchPathDelta SPDelta_25; 373 SearchPathDelta SPDelta_26; 374 SearchPathDelta SPDelta_27; 375 }; 376 uint32_t Value; 377 } DW22; 378 379 // DW23 380 union 381 { 382 struct 383 { 384 SearchPathDelta SPDelta_28; 385 SearchPathDelta SPDelta_29; 386 SearchPathDelta SPDelta_30; 387 SearchPathDelta SPDelta_31; 388 }; 389 uint32_t Value; 390 } DW23; 391 392 // DW24 393 union 394 { 395 struct 396 { 397 SearchPathDelta SPDelta_32; 398 SearchPathDelta SPDelta_33; 399 SearchPathDelta SPDelta_34; 400 SearchPathDelta SPDelta_35; 401 }; 402 uint32_t Value; 403 } DW24; 404 405 // DW25 406 union 407 { 408 struct 409 { 410 SearchPathDelta SPDelta_36; 411 SearchPathDelta SPDelta_37; 412 SearchPathDelta SPDelta_38; 413 SearchPathDelta SPDelta_39; 414 }; 415 uint32_t Value; 416 } DW25; 417 418 // DW26 419 union 420 { 421 struct 422 { 423 SearchPathDelta SPDelta_40; 424 SearchPathDelta SPDelta_41; 425 SearchPathDelta SPDelta_42; 426 SearchPathDelta SPDelta_43; 427 }; 428 uint32_t Value; 429 } DW26; 430 431 // DW27 432 union 433 { 434 struct 435 { 436 SearchPathDelta SPDelta_44; 437 SearchPathDelta SPDelta_45; 438 SearchPathDelta SPDelta_46; 439 SearchPathDelta SPDelta_47; 440 }; 441 uint32_t Value; 442 } DW27; 443 444 // DW28 445 union 446 { 447 struct 448 { 449 SearchPathDelta SPDelta_48; 450 SearchPathDelta SPDelta_49; 451 SearchPathDelta SPDelta_50; 452 SearchPathDelta SPDelta_51; 453 }; 454 uint32_t Value; 455 } DW28; 456 457 // DW29 458 union 459 { 460 struct 461 { 462 SearchPathDelta SPDelta_52; 463 SearchPathDelta SPDelta_53; 464 SearchPathDelta SPDelta_54; 465 SearchPathDelta SPDelta_55; 466 }; 467 uint32_t Value; 468 } DW29; 469 } SpDelta; 470 471 // DW30 472 union 473 { 474 struct 475 { 476 uint32_t Reserved; 477 }; 478 uint32_t Value; 479 } DW30; 480 481 // DW31 482 union 483 { 484 struct 485 { 486 uint32_t Reserved; 487 }; 488 uint32_t Value; 489 } DW31; 490 491 // DW32 492 union 493 { 494 struct 495 { 496 uint32_t _4xMeMvOutputDataSurfIndex; 497 }; 498 uint32_t Value; 499 } DW32; 500 501 // DW33 502 union 503 { 504 struct 505 { 506 uint32_t _16xOr32xMeMvInputDataSurfIndex; 507 }; 508 uint32_t Value; 509 } DW33; 510 511 // DW34 512 union 513 { 514 struct 515 { 516 uint32_t _4xMeOutputDistSurfIndex; 517 }; 518 uint32_t Value; 519 } DW34; 520 521 // DW35 522 union 523 { 524 struct 525 { 526 uint32_t _4xMeOutputBrcDistSurfIndex; 527 }; 528 uint32_t Value; 529 } DW35; 530 531 // DW36 532 union 533 { 534 struct 535 { 536 uint32_t VMEFwdInterPredictionSurfIndex; 537 }; 538 uint32_t Value; 539 } DW36; 540 541 // DW37 542 union 543 { 544 struct 545 { 546 uint32_t VMEBwdInterPredictionSurfIndex; 547 }; 548 uint32_t Value; 549 } DW37; 550 551 // DW38 552 union 553 { 554 struct 555 { 556 uint32_t Reserved; 557 }; 558 uint32_t Value; 559 } DW38; 560 561 } m_data; 562 563 static const uint32_t m_curbeSize = sizeof(CurbeData); 564 static const uint32_t m_initCurbe[39]; 565 }; 566 // clang-format on 567 568 //! 569 //! \brief Constructor 570 //! 571 //! \param [in] me4xDistBufferSupported 572 //! flag to support 4x Distortion buffer 573 //! 574 CodechalKernelHmeG8( 575 CodechalEncoderState *encoder, 576 bool me4xDistBufferSupported = true); 577 578 protected: GetCurbeSize()579 uint32_t GetCurbeSize() { return Curbe::m_curbeSize; } 580 MOS_STATUS SetCurbe(MHW_KERNEL_STATE *kernelState); 581 }; 582 583 #endif /* __CODECHAL_KERNEL_HME_G8_H__ */ 584