Debian Codegraph @

media_driver/agnostic/gen8/codec/hal/codechal_kernel_hme_g8.h

raw
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:
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:
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__ */