Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_encode_vp8.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_encode_vp8.h
24 //! \brief This file defines the base C++ class/interface for VP8 DualPipe encoding
25 //! to be used across CODECHAL components.
26 //!
27
28 #ifndef __CODECHAL_ENCODE_VP8_H__
29 #define __CODECHAL_ENCODE_VP8_H__
30
31 #include "codechal_encoder_base.h"
32
33 #define CODECHAL_NUM_VP8_ENC_SYNC_TAGS 36
34 #define CODECHAL_INIT_DSH_SIZE_VP8_ENC MHW_PAGE_SIZE * 2
35
36 #define CODECHAL_ENCODE_VP8_INVALID_PIC_ID CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8
37
38 #define VP8_NUM_COEFF_PLANES 4
39 #define VP8_NUM_COEFF_BANDS 8
40 #define VP8_NUM_LOCAL_COMPLEXITIES 3
41 #define VP8_NUM_COEFF_NODES 11
42 #define VP8_LAST_REF_FLAG 0x1
43 #define VP8_GOLDEN_REF_FLAG 0x2
44 #define VP8_ALT_REF_FLAG 0x4
45
46 #define INTERMEDIATE_PARTITION0_SIZE (64 * 1024)
47 #define TOKEN_STATISTICS_SIZE (304 * sizeof(uint32_t)) //270 tokens + 34 DWs for partition and segment info
48 #define COEFFS_PROPABILITIES_SIZE (VP8_NUM_COEFF_PLANES * VP8_NUM_COEFF_BANDS * VP8_NUM_LOCAL_COMPLEXITIES * VP8_NUM_COEFF_NODES) //1056
49 #define HISTOGRAM_SIZE (136 * sizeof(uint32_t))
50 #define MODE_PROPABILITIES_SIZE 96
51 #define HEADER_METADATA_SIZE (32 * sizeof(uint32_t))
52 #define PICTURE_STATE_CMD_SIZE (37 * sizeof(uint32_t))
53 #define PICTURE_STATE_SIZE (PICTURE_STATE_CMD_SIZE + HEADER_METADATA_SIZE + (16 * sizeof(uint32_t))) // + Extra dws for NOOP and BB_End
54 #define HEADER_METADATA_OFFSET (PICTURE_STATE_CMD_SIZE + (3 * sizeof(uint32_t))) //Add one extra noop
55 #define MPU_BITSTREAM_SIZE 128
56 #define TPU_BITSTREAM_SIZE 1344
57 #define ENTROPY_COST_TABLE_SIZE (256 * sizeof(uint32_t))
58 #define MPU_CURBE_SIZE (24 * sizeof(uint32_t))
59 #define TOKEN_BITS_DATA_SIZE (16 * sizeof(uint32_t))
60 #define VP8_KERNEL_DUMP_SIZE (600000 * sizeof(uint32_t))
61 #define VP8_MODE_COST_UPDATE_SURFACE_SIZE 64
62 #define REPAK_DECISION_BUF_SIZE (4 * sizeof(uint32_t))
63
64 #define VP8_ALL_DC_BIAS_DEFAULT 1500
65 #define CODECHAL_VP8_QP_MAX 127
66 #define CODECHAL_VP8_MODE_COST_SURFACE_SIZE 64
67
68 #define BRC_CONSTANTSURFACE_VP8 2880
69 #define CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_WIDTH 64
70 #define CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_HEIGHT 44
71
72 //*------------------------------------------------------------------------------
73 //* Codec Definitions
74 //*------------------------------------------------------------------------------
75
76 enum CodechalEncodeVp8MbencKernelStateIdx
77 {
78 CODECHAL_ENCODE_VP8_MBENC_IDX_I_CHROMA = 0,
79 CODECHAL_ENCODE_VP8_MBENC_IDX_I_LUMA,
80 CODECHAL_ENCODE_VP8_MBENC_IDX_P,
81 CODECHAL_ENCODE_VP8_MBENC_IDX_NUM
82 };
83
84 enum CodechalEncodeVp8BrcKernelStateIdx
85 {
86 CODECHAL_ENCODE_VP8_BRC_IDX_IFRAMEDIST = 0,
87 CODECHAL_ENCODE_VP8_BRC_IDX_INIT,
88 CODECHAL_ENCODE_VP8_BRC_IDX_RESET,
89 CODECHAL_ENCODE_VP8_BRC_IDX_UPDATE,
90 CODECHAL_ENCODE_VP8_BRC_IDX_NUM,
91 };
92
93 enum CodechalEncodeVp8MbpakKernelStateIdx
94 {
95 CODECHAL_ENCODE_VP8_MBPAK_IDX_PHASE1 = 0,
96 CODECHAL_ENCODE_VP8_MBPAK_IDX_PHASE2,
97 CODECHAL_ENCODE_VP8_MBPAK_IDX_NUM
98 };
99
100 static const uint8_t CodecHal_TargetUsageToMode_VP8[NUM_TARGET_USAGE_MODES] =
101 {
102 encodeNormalMode,
103 encodeQualityMode,
104 encodeQualityMode,
105 encodeNormalMode,
106 encodeNormalMode,
107 encodeNormalMode,
108 encodePerformanceMode,
109 encodePerformanceMode
110 };
111
112 struct CodechalVp8ModeCostUpdateSurface
113 {
114 union
115 {
116 struct
117 {
118 uint32_t : 16;
119 uint32_t Intra16x16 : 16;
120 };
121 struct
122 {
123 uint32_t Value;
124 };
125 } DW0;
126
127 union
128 {
129 struct
130 {
131 uint32_t : 16;
132 uint32_t Intra4x4 : 16;
133 };
134 struct
135 {
136 uint32_t Value;
137 };
138 } DW1;
139
140 union
141 {
142 struct
143 {
144 uint32_t Inter16x8 : 16;
145 uint32_t Inter8x8 : 16;
146 };
147 struct
148 {
149 uint32_t Value;
150 };
151 } DW2;
152
153 union
154 {
155 struct
156 {
157 uint32_t : 16;
158 uint32_t Inter4x4 : 16;
159 };
160 struct
161 {
162 uint32_t Value;
163 };
164 } DW3;
165
166 union
167 {
168 struct
169 {
170 uint32_t : 32;
171 };
172 struct
173 {
174 uint32_t Value;
175 };
176 } DW4;
177
178 union
179 {
180 struct
181 {
182 uint32_t : 32;
183 };
184 struct
185 {
186 uint32_t Value;
187 };
188 } DW5;
189
190 union
191 {
192 struct
193 {
194 uint32_t IntraNonDCPenalty16x16 : 16;
195 uint32_t IntraNonDCPenalty4x4 : 16;
196 };
197 struct
198 {
199 uint32_t Value;
200 };
201 } DW6;
202
203 union
204 {
205 struct
206 {
207 uint32_t RefFrameCostIntra : 16;
208 uint32_t RefFrameCostLast : 16;
209 };
210 struct
211 {
212 uint32_t Value;
213 };
214 } DW7;
215
216 union
217 {
218 struct
219 {
220 uint32_t RefFrameCostGold : 16;
221 uint32_t RefFrameCostAlt : 16;
222 };
223 struct
224 {
225 uint32_t Value;
226 };
227 } DW8;
228
229 };
230
231 struct CodechalBindingTableVp8BrcUpdate
232 {
233 uint32_t dwBrcHistoryBuffer;
234 uint32_t dwBrcPakStatisticsOutputBuffer;
235 uint32_t dwBrcMSDKPakSurfaceBuffer;
236 uint32_t dwBrcEncoderCfgReadBuffer;
237 uint32_t dwBrcEncoderCfgWriteBuffer;
238 uint32_t dwBrcMbPak1CurbeWriteBuffer;
239 uint32_t dwBrcMbPak2CurbeWriteBuffer;
240 uint32_t dwBrcMbPakInputMSDKBuffer;
241 uint32_t dwBrcMbPakTableData;
242 uint32_t dwBrcMbEncCurbeReadBuffer;
243 uint32_t dwBrcMbEncCurbeWriteData;
244 uint32_t dwBrcMpuCurbeReadBuffer;
245 uint32_t dwBrcMpuCurbeWriteData;
246 uint32_t dwBrcTpuCurbeReadBuffer;
247 uint32_t dwBrcTpuCurbeWriteData;
248 uint32_t dwBrcDistortionBuffer;
249 uint32_t dwBrcConstantData;
250 uint32_t dwVp8BrcSegmentationMap;
251 uint32_t dwBindingTableStartOffset;
252 uint32_t dwNumBindingTableEntries;
253 };
254
255 struct CodechalBindingTableVp8Mbenc
256 {
257 uint32_t dwVp8MBEncMBOut;
258 uint32_t dwVp8MBEncCurrY;
259 uint32_t dwVp8MBEncCurrUV;
260 uint32_t dwVp8MBEncMVDataFromME;
261 uint32_t dwVp8MBEncIndMVData;
262 uint32_t dwVp8MBEncCurrPic;
263 uint32_t dwVp8MBEncLastRefPic;
264 uint32_t dwVp8MBEncGoldenRefPic;
265 uint32_t dwVp8MBEncAlternateRefPic;
266 uint32_t dwVp8MBEncRef1Pic;
267 uint32_t dwVp8MBEncRef2Pic;
268 uint32_t dwVp8MBEncRef3Pic;
269 uint32_t dwVp8MBEncMBModeCostLuma;
270 uint32_t dwVp8MBEncBlockModeCost;
271 uint32_t dwVp8MBEncChromaRecon;
272 uint32_t dwVp8MBEncPerMBQuantDataI;
273 uint32_t dwVp8MBEncPerMBQuantDataP;
274 uint32_t dwVp8MBEncRefMBCount;
275 uint32_t dwVp8MBEncVMEInterPred;
276 uint32_t dwVp8MBEncVMEDebugStreamoutI;
277 uint32_t dwVp8MBEncVMEDebugStreamoutP;
278 uint32_t dwVp8MBEncSegmentationMap;
279 uint32_t dwVp8MBEncSegmentationMapP;
280 uint32_t dwVp8MBEncHistogram;
281 uint32_t dwVp8MBEncHistogramP;
282 uint32_t dwVp8MBEncVME;
283 uint32_t dwBindingTableStartOffset;
284 uint32_t dwNumBindingTableEntries;
285 uint32_t dwVp8InterPredDistortion;
286 uint32_t dwVp8PerMVDataSurface;
287 uint32_t dwVp8MBModeCostUpdateSurface;
288 uint32_t dwVp8MBEncBRCDist;
289 uint32_t dwVp8MBEncVMECoarseIntra;
290 uint32_t dwVp8MbEncCurrYDownscaled;
291 uint32_t dwVp8MbEncSwscoreboardI;
292 uint32_t dwVp8MbEncSwscoreboardP;
293 };
294
295 struct CodechalBindingTableVp8Me
296 {
297 uint32_t dwVp8MEMVDataSurface;
298 uint32_t dwVp816xMEMVDataSurface;
299 uint32_t dwVp8MeDist;
300 uint32_t dwVp8MeBrcDist;
301 uint32_t dwVp8MeCurrPic;
302 uint32_t dwVp8MeRef1Pic;
303 uint32_t dwVp8MeRef2Pic;
304 uint32_t dwVp8MeRef3Pic;
305 uint32_t dwVp8MeLastRefPic;
306 uint32_t dwVp8MeGoldenRefPic;
307 uint32_t dwVp8MeAlternateRefPic;
308 uint32_t dwBindingTableStartOffset;
309 uint32_t dwNumBindingTableEntries;
310 };
311
312 struct CodechalBindingTableVp8Mbpak
313 {
314 uint32_t dwVp8MBPakPerMBOut;
315 uint32_t dwVp8MBPakCurrY;
316 uint32_t dwVp8MBPakCurrUV;
317 uint32_t dwVp8MBPakLastRefY;
318 uint32_t dwVp8MBPakLastRefUV;
319 uint32_t dwVp8MBPakGoldenRefY;
320 uint32_t dwVp8MBPakGoldenRefUV;
321 uint32_t dwVp8MBPakAlternateRefY;
322 uint32_t dwVp8MBPakAlternateRefUV;
323 uint32_t dwVp8MBPakIndMVData;
324 uint32_t dwVp8MBPakCurrReconY;
325 uint32_t dwVp8MBPakCurrReconUV;
326 uint32_t dwVp8MBPakRowBuffY;
327 uint32_t dwVp8MBPakRowBuffUV;
328 uint32_t dwVp8MBPakColBuffY;
329 uint32_t dwVp8MBPakColBuffUV;
330 uint32_t dwVp8MBPakDebugStreamout;
331 uint32_t dwBindingTableStartOffset;
332 uint32_t dwNumBindingTableEntries;
333 };
334
335 struct CodechalBindingTableVp8Mpu
336 {
337 uint32_t dwVp8MpuHistogram;
338 uint32_t dwVp8MpuReferenceModeProbability;
339 uint32_t dwVp8MpuModeProbability;
340 uint32_t dwVp8MpuReferenceTokenProbability;
341 uint32_t dwVp8MpuTokenProbability;
342 uint32_t dwVp8MpuFrameHeaderBitstream;
343 uint32_t dwVp8MpuHeaderMetaData;
344 uint32_t dwVp8MpuPictureState;
345 uint32_t dwVp8MpuMpuBitstream;
346 uint32_t dwVp8MpuKernelDebugDump;
347 uint32_t dwVp8MpuEntropyCost;
348 uint32_t dwVp8MpuTokenBitsData;
349 uint32_t dwBindingTableStartOffset;
350 uint32_t dwNumBindingTableEntries;
351 uint32_t dwVp8MpuModeCostUpdateSurface;
352 };
353
354 struct CodechalBindingTableVp8Tpu
355 {
356 uint32_t dwVp8TpuPakTokenStatistics;
357 uint32_t dwVp8TpuTokenUpdateFlags;
358 uint32_t dwVp8TpuEntropyCost;
359 uint32_t dwVp8TpuFrameHeaderBitstream;
360 uint32_t dwVp8TpuDefaultTokenProbability;
361 uint32_t dwVp8TpuPictureState;
362 uint32_t dwVp8TpuMpuCurbeData;
363 uint32_t dwVp8TpuHeaderMetaData;
364 uint32_t dwVp8TpuTokenProbability;
365 uint32_t dwVp8TpuPakHardwareTokenProbabilityPass1;
366 uint32_t dwVp8TpuKeyFrameTokenProbability;
367 uint32_t dwVp8TpuUpdatedTokenProbability;
368 uint32_t dwVp8TpuPakHardwareTokenProbabilityPass2;
369 uint32_t dwVp8TpuKernelDebugDump;
370 uint32_t dwVp8TpuRepakDecision;
371 uint32_t dwBindingTableStartOffset;
372 uint32_t dwNumBindingTableEntries;
373 };
374
375 struct CodechalVp8BrcInitResetCurbeParams
376 {
377 CODEC_PICTURE CurrPic;
378 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams;
379 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams;
380 uint32_t dwFrameWidth;
381 uint32_t dwFrameHeight;
382 uint32_t dwAVBRAccuracy;
383 uint32_t dwAVBRConvergence;
384 double *pdBrcInitCurrentTargetBufFullInBits; // Passed back to Render Interface
385 double *pdBrcInitResetInputBitsPerFrame; // Passed back to Render Interface
386 uint32_t *pdwBrcInitResetBufSizeInBits; // Passed back to Render Interface
387 bool bInitBrc;
388 bool bMbBrcEnabled;
389 uint32_t dwFramerate;
390 PMHW_KERNEL_STATE pKernelState;
391 };
392
393 struct CodechalVp8BrcUpdateCurbeParams
394 {
395 CODEC_PICTURE CurrPic;
396 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams;
397 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams;
398 PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pSliceParams;
399 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData;
400 uint16_t wPictureCodingType;
401 uint32_t dwAVBRAccuracy;
402 uint32_t dwAVBRConvergence;
403 uint32_t dwFrameWidthInMB;
404 uint32_t dwFrameHeightInMB;
405 uint32_t dwBrcInitResetBufSizeInBits;
406 double dBrcInitResetInputBitsPerFrame;
407 double *pdBrcInitCurrentTargetBufFullInBits; // Passed in and back
408 bool bHmeEnabled;
409 bool bInitBrc;
410 bool bUsedAsRef;
411 uint8_t ucKernelMode; // Normal/Quality/Performance
412 uint32_t dwVp8BrcNumPakPasses;
413 uint32_t dwHeaderBytesInserted; // dwHeaderBytesInserted is for WAAVCSWHeaderInsertion and is 0 otherwise
414 bool bMultiRefQpEnabled;
415 uint32_t wFrameNumber;
416 };
417
418 struct CodechalVp8MeCurbeParams
419 {
420 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams;
421 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams;
422 uint32_t dwFrameWidth;
423 uint32_t dwFrameFieldHeight;
424 uint16_t wPictureCodingType;
425 bool b16xME;
426 bool b16xMeEnabled;
427 uint8_t ucKernelMode;
428 };
429
430 struct CodechalVp8MbencCurbeParams
431 {
432 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams;
433 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams;
434 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData;
435 PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pVp8SliceParams;
436 PCODEC_REF_LIST *ppRefList;
437 uint16_t wPicWidthInMb;
438 uint16_t wFieldFrameHeightInMb;
439 uint16_t wPictureCodingType;
440 bool bHmeEnabled;
441 bool bVmeKernelDump;
442 bool bMbEncIFrameDistEnabled;
443 bool bBrcEnabled;
444 uint8_t ucKernelMode; // normal, performance, quality.
445 bool bMbEncIFrameDistInUse;
446 PCODEC_PICTURE pCurrOriginalPic;
447 PCODEC_PICTURE pLastRefPic;
448 PCODEC_PICTURE pGoldenRefPic;
449 PCODEC_PICTURE pAlternateRefPic;
450 PMHW_KERNEL_STATE pKernelState;
451 };
452
453 struct CodechalVp8MbpakCurbeParams
454 {
455 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams;
456 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams;
457 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData;
458 PCODEC_REF_LIST *ppRefList;
459 uint16_t wPicWidthInMb;
460 uint16_t wFieldFrameHeightInMb;
461 uint16_t wPictureCodingType;
462 bool bHmeEnabled;
463 bool bVmeKernelDump;
464 uint8_t ucKernelMode; // normal, performance, quality.
465 CODECHAL_MEDIA_STATE_TYPE EncFunctionType;
466 PMHW_KERNEL_STATE pKernelState;
467 };
468
469 struct CodechalVp8MpuCurbeParams
470 {
471 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams;
472 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams;
473 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData;
474 uint16_t wPictureCodingType;
475 bool bVmeKernelDump;
476 uint8_t ucKernelMode; // normal, performance, quality.
477 CODECHAL_MEDIA_STATE_TYPE EncFunctionType;
478 };
479
480 struct CodechalVp8TpuCurbeParams
481 {
482 PCODEC_VP8_ENCODE_SEQUENCE_PARAMS pSeqParams;
483 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams;
484 PCODEC_VP8_ENCODE_QUANT_DATA pVp8QuantData;
485 uint16_t wPictureCodingType;
486 uint16_t wPicWidthInMb;
487 uint16_t wFieldFrameHeightInMb;
488 bool bVmeKernelDump;
489 uint8_t ucKernelMode; // normal, performance, quality.
490 CODECHAL_MEDIA_STATE_TYPE EncFunctionType;
491 bool bRebinarizationFrameHdr;
492 bool bAdaptiveRePak;
493 };
494
495 struct CodechalVp8BrcInitResetSurfaceParams
496 {
497 PMOS_RESOURCE presBrcHistoryBuffer;
498 PMOS_SURFACE psMeBrcDistortionBuffer;
499 uint32_t dwMeBrcDistortionBottomFieldOffset;
500 uint32_t dwDownscaledWidthInMb4x;
501 uint32_t dwDownscaledFrameHeightInMb4x;
502 PMHW_KERNEL_STATE pKernelState;
503 };
504
505 struct CodechalVp8BrcUpdateSurfaceParams
506 {
507 PMHW_KERNEL_STATE pMbEncKernelState;
508 PMOS_RESOURCE presBrcHistoryBuffer; // BRC history buffer
509 PMOS_RESOURCE presBrcPakStatisticBuffer; // BRC PAKStatistic buffer
510 PMOS_RESOURCE presVp8BrcConstantDataBuffer;
511 PMOS_RESOURCE presVp8EncoderCfgCommandReadBuffer;
512 PMOS_RESOURCE presVp8EncoderCfgCommandWriteBuffer;
513 PMOS_RESOURCE presVp8PakQPInputTable;
514 PMOS_RESOURCE presMbCodeBuffer;
515 PMOS_SURFACE ps4xMeDistortionBuffer;
516 PMOS_SURFACE psMeBrcDistortionBuffer;
517 MOS_RESOURCE resMbBrcConstDataBuffer;
518 uint32_t dwDownscaledWidthInMb4x;
519 uint32_t dwDownscaledFrameFieldHeightInMb4x;
520 bool bMbBrcEnabled;
521 PMOS_SURFACE psSegmentationMap;
522 uint32_t dwEncoderCfgCommandOffset;
523 PMHW_KERNEL_STATE pKernelState;
524 uint16_t wPictureCodingType; // I, P frame
525 uint32_t dwBrcPakStatisticsSize;
526 };
527
528 struct CodechalVp8MeSurfaceParams
529 {
530 PCODEC_REF_LIST *ppRefList;
531 PCODEC_PICTURE pLastRefPic;
532 PCODEC_PICTURE pGoldenRefPic;
533 PCODEC_PICTURE pAlternateRefPic;
534 PMOS_SURFACE ps4xMeMvDataBuffer;
535 PMOS_SURFACE ps16xMeMvDataBuffer;
536 PMOS_SURFACE psMeDistortionBuffer;
537 PMOS_SURFACE psMeBrcDistortionBuffer;
538 uint32_t dwDownscaledWidthInMb;
539 uint32_t dwDownscaledHeightInMb;
540 uint32_t dwVerticalLineStride;
541 uint32_t dwVerticalLineStrideOffset;
542 bool b16xMeInUse;
543 bool b16xMeEnabled;
544 uint32_t RefCtrl;
545 struct CodechalBindingTableVp8Me* pMeBindingTable;
546 PMHW_KERNEL_STATE pKernelState;
547 };
548
549 struct CodechalVp8MbencSurfaceParams
550 {
551 CODECHAL_MEDIA_STATE_TYPE MediaStateType;
552 PCODEC_REF_LIST *ppRefList;
553 PCODEC_PICTURE pCurrReconstructedPic;
554 PCODEC_PICTURE pLastRefPic;
555 PCODEC_PICTURE pGoldenRefPic;
556 PCODEC_PICTURE pAlternateRefPic;
557 uint16_t wPictureCodingType;
558 PMOS_SURFACE psCurrPicSurface;
559 uint32_t dwCurrPicSurfaceOffset;
560 uint32_t dwMvOffset;
561 uint32_t dwHistogramSize;
562 PMOS_SURFACE ps4xMeMvDataBuffer;
563 PMOS_SURFACE ps4xMeDistortionBuffer;
564 PMOS_SURFACE psMeBrcDistortionBuffer;
565 uint32_t dwOriFrameWidth;
566 uint32_t dwOriFrameHeight;
567 uint32_t dwVerticalLineStride;
568 uint32_t dwVerticalLineStrideOffset;
569 uint32_t dwFrameWidthInMb;
570 uint32_t dwFrameFieldHeightInMb;
571 bool bHmeEnabled;
572 bool bVMEKernelDump;
573 bool bSegmentationEnabled;
574 bool bMbEncIFrameDistInUse;
575 uint32_t dwMbDataOffset;
576 uint32_t uiRefCtrl;
577 PMOS_RESOURCE presPerMB_MBCodeOpData;
578 PMOS_SURFACE psMBModeCostLumaBuffer;
579 PMOS_SURFACE psBlockModeCostBuffer;
580 PMOS_RESOURCE psChromaReconBuffer; //for FF Vp8
581 PMOS_SURFACE psPerMBQuantDataBuffer;
582 PMOS_RESOURCE presRefMbCountSurface;
583 PMOS_RESOURCE presVmeKernelDumpBuffer;
584 PMOS_SURFACE psSegmentationMap;
585 PMOS_RESOURCE presHistogram;
586 PMOS_SURFACE psInterPredictionDistortionSurface;
587 PMOS_RESOURCE presPerMVDataSurface;
588 PMOS_RESOURCE presModeCostUpdateSurface;
589 PCODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE pVp8SliceParams;
590 struct CodechalBindingTableVp8Mbenc* pMbEncBindingTable;
591 PMHW_KERNEL_STATE pKernelState;
592 };
593
594 struct CodechalVp8MbpakSurfaceParams
595 {
596 CODECHAL_MEDIA_STATE_TYPE MediaStateType;
597 PCODEC_REF_LIST *ppRefList;
598 PCODEC_PICTURE pCurrReconstructedPic;
599 PCODEC_PICTURE pLastRefPic;
600 PCODEC_PICTURE pGoldenRefPic;
601 PCODEC_PICTURE pAlternateRefPic;
602 uint16_t wPictureCodingType;
603 uint32_t dwCurrPicSurfaceOffset;
604 uint32_t dwMvOffset;
605 uint32_t dwOriFrameWidth;
606 uint32_t dwOriFrameHeight;
607 uint32_t dwVerticalLineStride;
608 uint32_t dwVerticalLineStrideOffset;
609 bool bVMEKernelDump;
610 uint32_t dwMbDataOffset;
611 PMOS_RESOURCE presPerMB_MBCodeOpData;
612 PMOS_RESOURCE presRowBuffY;
613 PMOS_RESOURCE presRowBuffUV;
614 PMOS_RESOURCE presColBuffY;
615 PMOS_RESOURCE presColBuffUV;
616 PMOS_RESOURCE presVmeKernelDumpBuffer;
617 struct CodechalBindingTableVp8Mbpak* pMbPakBindingTable;
618 PMHW_KERNEL_STATE pKernelState;
619 };
620
621 struct CodechalVp8MpuSurfaceParams
622 {
623 CODECHAL_MEDIA_STATE_TYPE MediaStateType;
624 uint32_t dwHistogramSize;
625 uint32_t dwModeProbabilitySize;
626 uint32_t dwTokenProbabilitySize;
627 uint32_t dwFrameHeaderSize;
628 uint32_t dwPictureStateSize;
629 uint32_t dwHeaderMetadataSize;
630 uint32_t dwMpuBitstreamSize;
631 uint32_t dwTpuBitstreamSize;
632 uint32_t dwEntropyCostTableSize;
633 uint32_t dwHeaderMetaDataOffset;
634 uint32_t dwTokenBitsDataSize;
635 uint32_t dwKernelDumpSize;
636 bool bVMEKernelDump;
637 PMOS_RESOURCE presHistogram;
638 PMOS_RESOURCE presRefModeProbability;
639 PMOS_RESOURCE presModeProbability;
640 PMOS_RESOURCE presRefTokenProbability;
641 PMOS_RESOURCE presTokenProbability;
642 PMOS_RESOURCE presFrameHeader;
643 PMOS_RESOURCE presHeaderMetadata;
644 PMOS_RESOURCE presPictureState;
645 PMOS_RESOURCE presMpuBitstream;
646 PMOS_RESOURCE presTpuBitstream;
647 PMOS_RESOURCE presVmeKernelDumpBuffer;
648 PMOS_RESOURCE presEntropyCostTable;
649 PMOS_RESOURCE presTokenBitsData;
650 PMOS_RESOURCE presModeCostUpdateBuffer;
651 PMHW_KERNEL_STATE pKernelState;
652 };
653
654 struct CodechalVp8TpuSurfaceParams
655 {
656 CODECHAL_MEDIA_STATE_TYPE MediaStateType;
657 uint32_t dwPakTokenStatsSize;
658 uint32_t dwTokenProbabilitySize;
659 uint32_t dwEntropyCostTableSize;
660 uint32_t dwFrameHeaderSize;
661 uint32_t dwPictureStateSize;
662 uint32_t dwMpuCurbeSize;
663 uint32_t dwHeaderMetadataSize;
664 uint32_t dwHeaderMetaDataOffset;
665 uint32_t dwKernelDumpSize;
666 uint32_t dwRepakDecision;
667 bool bVMEKernelDump;
668 PMOS_RESOURCE presPakTokenStatistics;
669 PMOS_RESOURCE presPakTokenUpdateFlags;
670 PMOS_RESOURCE presEntropyCostTable;
671 PMOS_RESOURCE presFrameHeader;
672 PMOS_RESOURCE presDefaultTokenProbability;
673 PMOS_RESOURCE presPictureState;
674 PMOS_RESOURCE presMpuCurbeData;
675 PMOS_RESOURCE presHeaderMetadata;
676 PMOS_RESOURCE presCurrFrameTokenProbability;
677 PMOS_RESOURCE presHwTokenProbabilityPass1;
678 PMOS_RESOURCE presKeyFrameTokenProbability;
679 PMOS_RESOURCE presUpdatedFrameTokenProbability;
680 PMOS_RESOURCE presHwTokenProbabilityPass2;
681 PMOS_RESOURCE presRepakDecisionSurface;
682 PMOS_RESOURCE presVmeKernelDumpBuffer;
683 PMHW_KERNEL_STATE pKernelState;
684 };
685
686 struct CodechalResourcesBrcParams
687 {
688 bool bHWWalker;
689 uint32_t dwDownscaledWidthInMB4x;
690 uint32_t dwDownscaledHeightInMB4x;
691 uint32_t dwDownscaledFieldHeightInMB4x;
692 uint32_t dwFrameWidthInMB;
693 uint32_t dwFrameHeightInMB;
694 };
695
696 struct CodechalVp8InitBrcConstantBufferParams
697 {
698 PMOS_INTERFACE pOsInterface;
699 PCODEC_PIC_ID pVp8PicIdx;
700 MOS_RESOURCE resBrcConstantDataBuffer; // sBrcConstantDataBuffer[uiCurrDSH]
701 uint32_t dwMbEncBlockBasedSkipEn;
702 PCODEC_VP8_ENCODE_PIC_PARAMS pPicParams; // pAvcPicParams[ucPPSIdx]
703 uint16_t wPictureCodingType;
704 };
705
706 struct CodechalVp8InitMbencConstantBufferParams
707 {
708 PMOS_INTERFACE pOsInterface;
709 MOS_SURFACE sMBModeCostLumaBuffer;
710 MOS_SURFACE sBlockModeCostBuffer;
711 PMOS_RESOURCE presHistogram;
712 };
713
714 struct CodechalVp8InitPakBufferParams
715 {
716 PMOS_INTERFACE pOsInterface;
717 PMOS_RESOURCE presCoeffProbsBuffer;
718 PMOS_RESOURCE presFrameHeaderBuffer;
719 uint8_t *pHeader;
720 uint32_t dwHeaderSize;
721 };
722
723 struct CodechalVp8UpdateMpuTpuBufferParams
724 {
725 PMOS_INTERFACE pOsInterface;
726 PMOS_RESOURCE presCurrFrameTokenProbability;
727 PMOS_RESOURCE presHwTokenProbabilityPass1;
728 PMOS_RESOURCE presKeyFrameTokenProbability;
729 PMOS_RESOURCE presHwTokenProbabilityPass2;
730 PMOS_RESOURCE presRepakDecisionSurface;
731 uint32_t dwCoeffProbsSize;
732 };
733
734 struct CodechalVp8MpuTpuBuffers
735 {
736 MOS_RESOURCE resRefModeProbs;
737 MOS_RESOURCE resModeProbs;
738 MOS_RESOURCE resRefCoeffProbs;
739 MOS_RESOURCE resCoeffProbs;
740 MOS_RESOURCE resPictureState;
741 MOS_RESOURCE resMpuBitstream;
742 MOS_RESOURCE resEntropyCostTable;
743 MOS_RESOURCE resTokenBitsData;
744 MOS_RESOURCE resTpuBitstream;
745 MOS_RESOURCE resPakTokenStatistics;
746 MOS_RESOURCE resPakTokenUpdateFlags;
747 MOS_RESOURCE resDefaultTokenProbability;
748 MOS_RESOURCE resKeyFrameTokenProbability;
749 MOS_RESOURCE resUpdatedTokenProbability;
750 MOS_RESOURCE resHwTokenProbabilityPass2;
751 MOS_RESOURCE resRepakDecisionSurface;
752 };
753
754 struct CodecEncodeVp8DumpState
755 {
756 MOS_SURFACE *sMbSegmentMapSurface;
757 MOS_SURFACE *s4xMEDistortionBuffer;
758 MHW_KERNEL_STATE *MpuKernelState;
759 MHW_KERNEL_STATE *TpuKernelState;
760 EncodeBrcBuffers *BrcBuffers;
761 struct CodechalVp8MpuTpuBuffers *MpuTpuBuffers;
762 MOS_RESOURCE *resFrameHeader;
763 bool *bBrcEnabled;
764 MOS_RESOURCE *resModeCostUpdateSurface;
765 MOS_RESOURCE *resHistogram;
766 };
767
768 struct CodechalEncodeVp8InitKernelStateParams
769 {
770 PMHW_KERNEL_STATE pKernelState;
771 MhwRenderInterface *pRenderEngineInterface;
772 uint8_t* pui8Binary;
773 EncOperation Operation;
774 uint32_t dwKrnStateIdx;
775 uint32_t dwCombinedKernelSize;
776 int32_t iBtCount;
777 int32_t iCurbeCount;
778 };
779
780
781 //!
782 //! \class CodechalEncodeVp8
783 //! \brief VP8 dual-pipe encoder base class
784 //! \details This class defines the base class for VP8 dual-pipe encoder, it includes
785 //! common member fields, functions, interfaces etc shared by all GENs.
786 //! Gen specific definitions, features should be put into their corresponding classes.
787 //! To create a VP8 dual-pipe encoder instance, client needs to call CodechalEncodeVp8::CreateVp8State()
788 //!
789 class CodechalEncodeVp8 : public CodechalEncoderState
790 {
791 public:
792
793 //!
794 //! \brief Destructor
795 //!
796 virtual ~CodechalEncodeVp8();
797
798 //!
799 //! \brief Allocate resources for encoder instance
800 //! \details It is invoked when initializing encoder instance
801 //!
802 //! \return MOS_STATUS
803 //! MOS_STATUS_SUCCESS if success, else fail reason
804 //!
805 MOS_STATUS AllocateResources();
806
807 //!
808 //! \brief Free encoder resources
809 //! \details It is invoked when destorying encoder instance and it would call
810 //! FreeEncResources(), FreeBrcResources() and FreePakResources()
811 //!
812 //! \return void
813 //!
814 void FreeResources();
815
816 //!
817 //! \brief Resize buffers due to resoluton change.
818 //! \details Resize buffers due to resoluton change.
819 //!
820 //! \return void
821 //!
822 virtual void ResizeBuffer();
823
824 //!
825 //! \brief Initialize encoder at picture level. Called by each frame.
826 //!
827 //! \param [in] params
828 //! Picture encoding parameters
829 //!
830 //! \return MOS_STATUS
831 //! MOS_STATUS_SUCCESS if success, else fail reason
832 //!
833 MOS_STATUS InitializePicture(const EncoderParams& params);
834
835 //!
836 //! \brief Encode kernel functions
837 //!
838 //! \return MOS_STATUS
839 //! MOS_STATUS_SUCCESS if success, else fail reason
840 //!
841 virtual MOS_STATUS ExecuteKernelFunctions();
842
843 //!
844 //! \brief Encode command at picture level
845 //!
846 //! \return MOS_STATUS
847 //! MOS_STATUS_SUCCESS if success, else fail reason
848 //!
849 MOS_STATUS ExecutePictureLevel();
850
851 //!
852 //! \brief Encode command at slice level
853 //!
854 //! \return MOS_STATUS
855 //! MOS_STATUS_SUCCESS if success, else fail reason
856 //!
857 MOS_STATUS ExecuteSliceLevel();
858
859 //!
860 //! \brief Initialize encoder instance
861 //! \details When GEN specific derived class implements this function to do its own initialization,
862 // it is required that the derived class calls #CodechalEncodeMpeg2::Initialize() first
863 // which would do common initialization for all GENs
864 //!
865 //! \return MOS_STATUS
866 //! MOS_STATUS_SUCCESS if success, else fail reason
867 //!
868 virtual MOS_STATUS Initialize(CodechalSetting * codecHalSettings);
869
870 //!
871 //! \brief Read Image Status
872 //!
873 //! \param [out] cmdBuffer
874 //! Pointer to MOS_COMMAND_BUFFER
875 //!
876 //! \return MOS_STATUS
877 //! MOS_STATUS_SUCCESS if success, else fail reason
878 //!
879 MOS_STATUS ReadImageStatus(PMOS_COMMAND_BUFFER cmdBuffer);
880
881 //!
882 //! \brief Read Mfc image Status
883 //!
884 //! \param [out] cmdBuffer
885 //! Pointer to MOS_COMMAND_BUFFER
886 //!
887 //! \return MOS_STATUS
888 //! MOS_STATUS_SUCCESS if success, else fail reason
889 //!
890 MOS_STATUS ReadMfcStatus(PMOS_COMMAND_BUFFER cmdBuffer);
891
892 //!
893 //! \brief Read Pak Statistics
894 //!
895 //! \param [in] params
896 //! Pointer to CODECHAL_ENCODE_READ_BRC_PAK_STATS_PARAMS
897 //! \param [out] cmdBuffer
898 //! Pointer to MOS_COMMAND_BUFFER
899 //!
900 //! \return MOS_STATUS
901 //! MOS_STATUS_SUCCESS if success, else fail reason
902 //!
903 MOS_STATUS ReadBrcPakStatistics(
904 PMOS_COMMAND_BUFFER cmdBuffer,
905 EncodeReadBrcPakStatsParams* params);
906
907 //!
908 //! \brief Get Status Report
909 //!
910 //! \param [in] encodeStatus
911 //! Pointer to CODECHAL_ENCODE_STATUS
912 //! \param [out] pEncodeStatusReport
913 //! Pointer to CODECHAL_ENCODE_STATUS_REPORT
914 //!
915 //! \return MOS_STATUS
916 //! MOS_STATUS_SUCCESS if success, else fail reason
917 //!
918 MOS_STATUS GetStatusReport(
919 EncodeStatus *encodeStatus,
920 EncodeStatusReport *pEncodeStatusReport);
921
922 //!
923 //! \brief Initialize MMC state
924 //!
925 //! \return MOS_STATUS
926 //! MOS_STATUS_SUCCESS if success
927 //!
928 virtual MOS_STATUS InitMmcState();
929
930 CODEC_VP8_ENCODE_PIC_PARAMS *m_vp8PicParams = nullptr; //<! Pointer to CodecVp8EncodePictureParams
931
932 #if USE_CODECHAL_DEBUG_TOOL
933 MOS_STATUS DumpMbEncPakOutput(PCODEC_REF_LIST currRefList, CodechalDebugInterface* debugInterface);
934 #endif // USE_CODECHAL_DEBUG_TOOL
935
936 protected:
937
938 //!
939 //! \brief Constructor
940 //!
941 CodechalEncodeVp8(
942 CodechalHwInterface* hwInterface,
943 CodechalDebugInterface* debugInterface,
944 PCODECHAL_STANDARD_INFO standardInfo);
945
946 //!
947 //! \brief Allocate Resource of BRC
948 //!
949 //! \param [in] params
950 //! Pointer to CODECHAL_RESOURCES_BRC_PARAMS
951 //!
952 //! \return MOS_STATUS
953 //! MOS_STATUS_SUCCESS if success, else fail reason
954 //!
955 MOS_STATUS AllocateBrcResources (struct CodechalResourcesBrcParams* params);
956
957 //!
958 //! \brief Help function to allocate a 1D buffer
959 //!
960 //! \param [in,out] buffer
961 //! Pointer to allocated buffer
962 //! \param [in] bufSize
963 //! Buffer size
964 //! \param [in] name
965 //! Buffer name
966 //!
967 //! \return MOS_STATUS
968 //! MOS_STATUS_SUCCESS if success, else fail reason
969 //!
970 MOS_STATUS AllocateBuffer(
971 PMOS_RESOURCE buffer,
972 uint32_t bufSize,
973 PCCHAR name);
974
975 //!
976 //! \brief Help function to allocate a generic 2D surface
977 //!
978 //! \param [in,out] surface
979 //! Pointer to allocated surface
980 //! \param [in] surfWidth
981 //! Surface width
982 //! \param [in] surfHeight
983 //! Surface height
984 //! \param [in] name
985 //! Surface name
986 //!
987 //! \return MOS_STATUS
988 //! MOS_STATUS_SUCCESS if success, else fail reason
989 //!
990 MOS_STATUS AllocateBuffer2D(
991 PMOS_SURFACE surface,
992 uint32_t surfWidth,
993 uint32_t surfHeight,
994 PCCHAR name);
995
996 //!
997 //! \brief Help function to allocate a batch buffer
998 //!
999 //! \param [in,out] batchBuffer
1000 //! Pointer to allocated batch buffer
1001 //! \param [in] bufSize
1002 //! Buffer size
1003 //! \param [in] name
1004 //! Batch buffer name
1005 //!
1006 //! \return MOS_STATUS
1007 //! MOS_STATUS_SUCCESS if success, else fail reason
1008 //!
1009 MOS_STATUS AllocateBatchBuffer(
1010 PMHW_BATCH_BUFFER batchBuffer,
1011 uint32_t bufSize,
1012 PCCHAR name);
1013
1014 //!
1015 //! \brief Free all Resources of BRC
1016 //!
1017 //! \return void
1018 //!
1019 void FreeBrcResources();
1020
1021 //!
1022 //! \brief Initialize kernel state
1023 //!
1024 //! \return MOS_STATUS
1025 //! MOS_STATUS_SUCCESS if success, else fail reason
1026 //!
1027 virtual MOS_STATUS InitKernelState() = 0;
1028
1029 //!
1030 //! \brief Initialize Mpu Tpu Buffer
1031 //!
1032 //! \return MOS_STATUS
1033 //! MOS_STATUS_SUCCESS if success, else fail reason
1034 //!
1035 virtual MOS_STATUS InitMpuTpuBuffer() = 0;
1036
1037 //!
1038 //! \brief Set Curbe for BRC Init or Reset
1039 //!
1040 //! \param [in] params
1041 //! Pointer to CODECHAL_VP8_BRC_INIT_RESET_CURBE_PARAMS
1042 //!
1043 //! \return MOS_STATUS
1044 //! MOS_STATUS_SUCCESS if success, else fail reason
1045 //!
1046 virtual MOS_STATUS SetBrcInitResetCurbe(struct CodechalVp8BrcInitResetCurbeParams* params) = 0;
1047
1048 //!
1049 //! \brief Send Surface for BRC Init or Reset
1050 //!
1051 //! \param [in] cmdBuffer
1052 //! Pointer to MOS_COMMAND_BUFFER
1053 //! \param [in] params
1054 //! Pointer to CODECHAL_VP8_BRC_INIT_RESET_SURFACE_PARAMS
1055 //!
1056 //! \return MOS_STATUS
1057 //! MOS_STATUS_SUCCESS if success, else fail reason
1058 //!
1059 virtual MOS_STATUS SendBrcInitResetSurfaces(
1060 PMOS_COMMAND_BUFFER cmdBuffer,
1061 struct CodechalVp8BrcInitResetSurfaceParams* params) = 0;
1062
1063 //!
1064 //! \brief Set Curbe for BRC Update
1065 //!
1066 //! \param [in] params
1067 //! Pointer to CODECHAL_VP8_BRC_UPDATE_CURBE_PARAMS
1068 //!
1069 //! \return MOS_STATUS
1070 //! MOS_STATUS_SUCCESS if success, else fail reason
1071 //!
1072 virtual MOS_STATUS SetBrcUpdateCurbe(struct CodechalVp8BrcUpdateCurbeParams* params) = 0;
1073
1074 //!
1075 //! \brief Send Surface for BRC Update
1076 //!
1077 //! \param [in] cmdBuffer
1078 //! Pointer to MOS_COMMAND_BUFFER
1079 //! \param [in] params
1080 //! Pointer to CODECHAL_VP8_BRC_UPDATE_SURFACE_PARAMS
1081 //!
1082 //! \return MOS_STATUS
1083 //! MOS_STATUS_SUCCESS if success, else fail reason
1084 //!
1085 MOS_STATUS SendBrcUpdateSurfaces(
1086 PMOS_COMMAND_BUFFER cmdBuffer,
1087 struct CodechalVp8BrcUpdateSurfaceParams* params);
1088
1089 //!
1090 //! \brief Set Curbe for Mb Enc
1091 //!
1092 //! \param [in] params
1093 //! Pointer to CODECHAL_VP8_MBENC_CURBE_PARAMS
1094 //!
1095 //! \return MOS_STATUS
1096 //! MOS_STATUS_SUCCESS if success, else fail reason
1097 //!
1098 virtual MOS_STATUS SetMbEncCurbe(struct CodechalVp8MbencCurbeParams* params) = 0;
1099
1100 //!
1101 //! \brief Set Curbe for ME
1102 //!
1103 //! \param [in] params
1104 //! Pointer to CODECHAL_VP8_ME_CURBE_PARAMS
1105 //!
1106 //! \return MOS_STATUS
1107 //! MOS_STATUS_SUCCESS if success, else fail reason
1108 //!
1109 virtual MOS_STATUS SetMeCurbe(struct CodechalVp8MeCurbeParams* params) = 0;
1110
1111 //!
1112 //! \brief Set Curbe for Mpu
1113 //!
1114 //! \param [in] params
1115 //! Pointer to CODECHAL_VP8_MPU_CURBE_PARAMS
1116 //!
1117 //! \return MOS_STATUS
1118 //! MOS_STATUS_SUCCESS if success, else fail reason
1119 //!
1120 virtual MOS_STATUS SetMpuCurbe(struct CodechalVp8MpuCurbeParams* params) = 0;
1121
1122 //!
1123 //! \brief Set Curbe for Tpu
1124 //!
1125 //! \param [in] params
1126 //! Pointer to CODECHAL_VP8_TPU_CURBE_PARAMS
1127 //!
1128 //! \return MOS_STATUS
1129 //! MOS_STATUS_SUCCESS if success, else fail reason
1130 //!
1131 virtual MOS_STATUS SetTpuCurbe(struct CodechalVp8TpuCurbeParams* params) = 0;
1132
1133 //!
1134 //! \brief BRC Constant Buffer Initialize
1135 //!
1136 //! \param [in] params
1137 //! Pointer to CODECHAL_VP8_INIT_BRC_CONSTANT_BUFFER_PARAMS params
1138 //!
1139 //! \return MOS_STATUS
1140 //! MOS_STATUS_SUCCESS if success, else fail reason
1141 //!
1142 virtual MOS_STATUS InitBrcConstantBuffer(struct CodechalVp8InitBrcConstantBufferParams* params) = 0;
1143
1144 //!
1145 //! \brief BRC Distortion Buffer Initialize
1146 //!
1147 //! \return MOS_STATUS
1148 //! MOS_STATUS_SUCCESS if success, else fail reason
1149 //!
1150 virtual MOS_STATUS InitBrcDistortionBuffer() = 0;
1151
1152 //!
1153 //! \brief Send Surface for ME
1154 //!
1155 //! \param [in] cmdBuffer
1156 //! Pointer to MOS_COMMAND_BUFFER
1157 //! \param [in] params
1158 //! Pointer to CODECHAL_VP8_ME_SURFACE_PARAMS
1159 //!
1160 //! \return MOS_STATUS
1161 //! MOS_STATUS_SUCCESS if success, else fail reason
1162 //!
1163 MOS_STATUS SendMeSurfaces(
1164 PMOS_COMMAND_BUFFER cmdBuffer,
1165 struct CodechalVp8MeSurfaceParams* params);
1166
1167 //!
1168 //! \brief Update MpuTpu Buffer with Key Frame
1169 //!
1170 //! \param [in] params
1171 //! Pointer to CODECHAL_VP8_UPDATE_MPU_TPU_BUFFER_PARAMS
1172 //!
1173 //! \return MOS_STATUS
1174 //! MOS_STATUS_SUCCESS if success, else fail reason
1175 //!
1176 virtual MOS_STATUS KeyFrameUpdateMpuTpuBuffer(struct CodechalVp8UpdateMpuTpuBufferParams* params) = 0;
1177
1178 //!
1179 //! \brief Send Surface for Mpu
1180 //!
1181 //! \param [in] cmdBuffer
1182 //! Pointer to MOS_COMMAND_BUFFER
1183 //! \param [in] params
1184 //! Pointer to CODECHAL_VP8_MPU_SURFACE_PARAMS
1185 //!
1186 //! \return MOS_STATUS
1187 //! MOS_STATUS_SUCCESS if success, else fail reason
1188 //!
1189 virtual MOS_STATUS SendMpuSurfaces(
1190 PMOS_COMMAND_BUFFER cmdBuffer,
1191 struct CodechalVp8MpuSurfaceParams* params) = 0;
1192
1193 //!
1194 //! \brief Send Surface for Tpu
1195 //!
1196 //! \param [in] cmdBuffer
1197 //! Pointer to MOS_COMMAND_BUFFER
1198 //! \param [in] params
1199 //! Pointer to CODECHAL_VP8_TPU_SURFACE_PARAMS
1200 //!
1201 //! \return MOS_STATUS
1202 //! MOS_STATUS_SUCCESS if success, else fail reason
1203 //!
1204 MOS_STATUS SendTpuSurfaces(
1205 PMOS_COMMAND_BUFFER cmdBuffer,
1206 struct CodechalVp8TpuSurfaceParams* params);
1207
1208 //!
1209 //! \brief MBEnc Constant Buffer initialize
1210 //!
1211 //! \param [in] params
1212 //! Pointer to CODECHAL_VP8_INIT_MBENC_CONSTANT_BUFFER_PARAMS
1213 //!
1214 //! \return MOS_STATUS
1215 //! MOS_STATUS_SUCCESS if success, else fail reason
1216 //!
1217 virtual MOS_STATUS InitMBEncConstantBuffer(struct CodechalVp8InitMbencConstantBufferParams* params) = 0;
1218
1219 //!
1220 //! \brief Send Surface for Mb Enc
1221 //!
1222 //! \param [in] cmdBuffer
1223 //! Pointer to MOS_COMMAND_BUFFER
1224 //! \param [in] params
1225 //! Pointer to CODECHAL_VP8_MBENC_SURFACE_PARAMS
1226 //!
1227 //! \return MOS_STATUS
1228 //! MOS_STATUS_SUCCESS if success, else fail reason
1229 //!
1230 virtual MOS_STATUS SendMbEncSurfaces(
1231 PMOS_COMMAND_BUFFER cmdBuffer,
1232 struct CodechalVp8MbencSurfaceParams* params);
1233
1234 //!
1235 //! \brief Set Pak Stats In Tpu Curbe
1236 //!
1237 //! \param [in] cmdBuffer
1238 //! Pointer to MOS_COMMAND_BUFFER
1239 //!
1240 //! \return MOS_STATUS
1241 //! MOS_STATUS_SUCCESS if success, else fail reason
1242 //!
1243 MOS_STATUS SetPakStatsInTpuCurbe(PMOS_COMMAND_BUFFER cmdBuffer);
1244
1245 //!
1246 //! \brief Setup/configure encoder based on sequence parameter set
1247 //! \details It is invoked when the encoder receives a new sequence parameter set and it would
1248 //! set up and configure the encoder state that used for the sequence
1249 //!
1250 //! \return MOS_STATUS
1251 //! MOS_STATUS_SUCCESS if success, else fail reason
1252 //!
1253 MOS_STATUS SetSequenceStructs();
1254
1255 //!
1256 //! \brief Setup/configure encoder based on picture parameter set
1257 //! \details It is invoked for every picture and it would set up and configure the
1258 //! encoder state that used for current picture
1259 //!
1260 //! \return MOS_STATUS
1261 //! MOS_STATUS_SUCCESS if success, else fail reason
1262 //!
1263 MOS_STATUS SetPictureStructs();
1264
1265 //!
1266 //! \brief Invoke BRC Init/Reset kernel
1267 //!
1268 //! \return MOS_STATUS
1269 //! MOS_STATUS_SUCCESS if success, else fail reason
1270 //!
1271 MOS_STATUS BrcInitResetKernel();
1272
1273 //!
1274 //! \brief Invoke BRC update kernel
1275 //!
1276 //! \return MOS_STATUS
1277 //! MOS_STATUS_SUCCESS if success, else fail reason
1278 //!
1279 MOS_STATUS BrcUpdateKernel();
1280
1281 //!
1282 //! \brief Top level function for invoking MBenc kernel
1283 //!
1284 //! \param [in] isEncPhase1NotRun
1285 //! Indicate if MbEnc Phase 1 is not enabled
1286 //! \param [in] isEncPhase2
1287 //! Indicate if MbEnc Phase 2 is enabled
1288 //! \param [in] mbEncIFrameDistInUse
1289 //! Indicate if MbEnc I-Frame distortion is enabled
1290 //!
1291 //! \return MOS_STATUS
1292 //! MOS_STATUS_SUCCESS if success, else fail reason
1293 //!
1294 MOS_STATUS MbEncKernel(
1295 bool isEncPhase1NotRun,
1296 bool isEncPhase2,
1297 bool mbEncIFrameDistInUse);
1298
1299 //!
1300 //! \brief Invoke ME kernel
1301 //!
1302 //! \return MOS_STATUS
1303 //! MOS_STATUS_SUCCESS if success, else fail reason
1304 //!
1305 MOS_STATUS MeKernel();
1306
1307 //!
1308 //! \brief Invoke MPU kernel
1309 //!
1310 //! \return MOS_STATUS
1311 //! MOS_STATUS_SUCCESS if success, else fail reason
1312 //!
1313 MOS_STATUS MpuKernel();
1314
1315 //!
1316 //! \brief Invoke TPU kernel
1317 //!
1318 //! \return MOS_STATUS
1319 //! MOS_STATUS_SUCCESS if success, else fail reason
1320 //!
1321 MOS_STATUS TpuKernel();
1322
1323 //!
1324 //! \brief Retrieves the MFC registers and stores them in the dump buffer
1325 //!
1326 //! \param [in] cmdBuffer
1327 //! Pointer to MOS_COMMAND_BUFFER
1328 //! \param [in] resource
1329 //! Pointer to MOS_RESOURCE
1330 //! \param [in] baseOffset
1331 //! Offset of base
1332 //!
1333 //! \return MOS_STATUS
1334 //! MOS_STATUS_SUCCESS if success, else fail reason
1335 //!
1336 MOS_STATUS SetPakStatsDebugBuffer(
1337 PMOS_COMMAND_BUFFER cmdBuffer,
1338 PMOS_RESOURCE resource,
1339 uint32_t baseOffset);
1340
1341 //!
1342 //! \brief Encode BRC command at slice level
1343 //!
1344 //! \param [in] cmdBuffer
1345 //! Pointer to MOS_COMMAND_BUFFER
1346 //!
1347 //! \return MOS_STATUS
1348 //! MOS_STATUS_SUCCESS if success, else fail reason
1349 //!
1350 MOS_STATUS EncodeSliceLevelBrc(PMOS_COMMAND_BUFFER cmdBuffer);
1351
1352 //!
1353 //! \brief Add Batch Buffer End to Picture State Command
1354 //!
1355 //! \return MOS_STATUS
1356 //! MOS_STATUS_SUCCESS if success, else fail reason
1357 //!
1358 MOS_STATUS AddBBEndToPicStateCmd();
1359
1360 //!
1361 //! \brief Get maximum BT count
1362 //!
1363 //! \return uint32_t
1364 //! Maximum BT count
1365 //!
1366 uint32_t GetMaxBtCount();
1367
1368 #if USE_CODECHAL_DEBUG_TOOL
1369 MOS_STATUS DumpVp8EncodePicParams(PCODEC_VP8_ENCODE_PIC_PARAMS picParams);
1370
1371 MOS_STATUS DumpVp8EncodeSeqParams(PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams);
1372 #endif // USE_CODECHAL_DEBUG_TOOL
1373
1374 MEDIA_FEATURE_TABLE * m_skuTable = nullptr; // SKU table
1375 MEDIA_WA_TABLE * m_waTable = nullptr; // SKU table
1376
1377 // Parameters passed by application
1378 CODEC_VP8_ENCODE_SEQUENCE_PARAMS * m_vp8SeqParams = nullptr;
1379 CODEC_VP8_ENCODE_QUANT_DATA * m_vp8QuantData = nullptr;
1380 CODECHAL_VP8_HYBRIDPAK_FRAMEUPDATE *m_vp8SliceParams = nullptr;
1381
1382 uint8_t* m_kernelBinary = nullptr; //!< Pointer to the kernel binary
1383 uint32_t m_combinedKernelSize = 0; //!< Combined kernel binary size
1384
1385 CODEC_PIC_ID m_picIdx[CODEC_MAX_NUM_REF_FRAME_NON_AVC];
1386 PCODEC_REF_LIST m_refList[CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8];
1387
1388 bool m_hmeEnabled = false;
1389 bool m_b16XMeEnabled = false;
1390 bool m_hmeDone = false;
1391 bool m_b16XMeDone = false;
1392 bool m_refCtrlOptimizationDone = false;
1393 bool m_brcInit = false;
1394 bool m_brcReset = false;
1395 bool m_brcEnabled = false;
1396 bool m_mbBrcEnabled = false;
1397 bool m_mbEncIFrameDistEnabled = false;
1398 bool m_brcDistortionBufferSupported = false;
1399 bool m_initBrcDistortionBuffer = false;
1400 bool m_brcConstantBufferSupported = false;
1401 bool m_brcSegMapSupported = false;
1402 bool m_mbEncCurbeSetInBrcUpdate;
1403 bool m_mbPakCurbeSetInBrcUpdate = false;
1404 bool m_mpuCurbeSetInBrcUpdate;
1405 bool m_tpuCurbeSetInBrcUpdate;
1406 bool m_mfxEncoderConfigCommandInitialized = false;
1407 bool m_adaptiveRepakSupported = false;
1408 bool m_repakSupported = false;
1409 uint16_t m_usMinPakPasses = 0;
1410 uint16_t m_usRepakPassIterVal = 0; // n th pass when Repak is executed
1411
1412 // MB Enc
1413 MHW_KERNEL_STATE m_mbEncKernelStates[CODECHAL_ENCODE_VP8_MBENC_IDX_NUM] = {};
1414 uint32_t m_numMbEncEncKrnStates = 0;
1415 uint32_t m_mbEncIFrameDshSize = 0;
1416 struct CodechalBindingTableVp8Mbenc m_mbEncBindingTable = {};
1417 uint32_t m_mbEncBlockBasedSkipEn = 0;
1418 MOS_RESOURCE m_resRefMbCountSurface = {};
1419 MOS_SURFACE m_mbModeCostLumaBuffer = {};
1420 MOS_SURFACE m_blockModeCostBuffer = {};
1421 MOS_RESOURCE m_chromaReconBuffer = {}; // for fixed function VP8
1422 MOS_SURFACE m_perMbQuantDataBuffer = {};
1423 MOS_RESOURCE m_resPredMvDataSurface = {};
1424 MOS_RESOURCE m_resHistogram = {};
1425 MOS_RESOURCE m_resModeCostUpdateSurface = {};
1426 // MBRC = 1: internal segment map (sInSegmentMapSurface) is provided from BRC update kernel
1427 // MBRC = 0: external segment map (sMbSegmentMapSurface) is provided from the app, ignore internal segment map
1428 MOS_SURFACE m_inSegmentMapSurface = {};
1429 MOS_SURFACE m_mbSegmentMapSurface = {}; // var of type MOS_SURFACE of Mb segment map surface
1430
1431 // MPU & TPU Buffers
1432 struct CodechalVp8MpuTpuBuffers m_mpuTpuBuffers = {};
1433
1434 // TPU
1435 MHW_KERNEL_STATE m_tpuKernelState = {};
1436 struct CodechalBindingTableVp8Tpu m_tpuBindingTable = {};
1437
1438 // MPU
1439 MHW_KERNEL_STATE m_mpuKernelState = {};
1440 struct CodechalBindingTableVp8Mpu m_mpuBindingTable = {};
1441
1442 // VME Scratch Buffers
1443 MOS_RESOURCE m_resVmeKernelDumpBuffer = {};
1444 bool m_vmeKernelDump = false;
1445
1446 //HW pak
1447 MOS_RESOURCE m_resIntraRowStoreScratchBuffer = {};
1448 MOS_RESOURCE m_resFrameHeader = {};
1449 MOS_RESOURCE m_resPakIntermediateBuffer = {};
1450
1451 // ME
1452 MHW_KERNEL_STATE m_meKernelState;
1453 struct CodechalBindingTableVp8Me m_meBindingTable = {};
1454 MOS_SURFACE m_s4XMemvDataBuffer;
1455 MOS_SURFACE m_s16XMemvDataBuffer = {};
1456 MOS_SURFACE m_s4XMeDistortionBuffer;
1457
1458 uint32_t m_averageKeyFrameQp = 0;
1459 uint32_t m_averagePFrameQp = 0;
1460 uint32_t m_pFramePositionInGop = 0;
1461 // BRC Params, these parameters not used for BDW
1462 MHW_KERNEL_STATE m_brcKernelStates[CODECHAL_ENCODE_VP8_BRC_IDX_NUM];
1463 struct CodechalBindingTableVp8BrcUpdate m_brcUpdateBindingTable = {};
1464 EncodeBrcBuffers m_brcBuffers;
1465 uint16_t m_usAvbrAccuracy = 0;
1466 uint16_t m_usAvbrConvergence = 0;
1467 double m_dBrcInitCurrentTargetBufFullInBits = 0;
1468 double m_dBrcInitResetInputBitsPerFrame = 0;
1469 uint32_t m_brcInitResetBufSizeInBits = 0;
1470 uint32_t m_brcConstantSurfaceWidth = 0;
1471 uint32_t m_brcConstantSurfaceHeight = 0;
1472
1473 uint32_t m_frameRate = 0;
1474 };
1475
1476 #endif // __CODECHAL_ENCODER_VP8_H__