1 /*
2 * Copyright (c) 2017-2024, 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 codec_def_common.h
24 //! \brief Defines common types and macros shared by CodecHal, MHW, and DDI layer
25 //! \details This is the base header for all codec_def files. All codec_def may include this file which should not contain any DDI specific code.
26 //!
27 #ifndef __CODEC_DEF_COMMON_H__
28 #define __CODEC_DEF_COMMON_H__
29
30 #include "mos_defs.h"
31 #include "mos_os.h"
32 #include "media_defs.h"
33 #include <math.h>
34
35 #define CODEC_MAX_NUM_REF_FRAME 16
36 #define CODEC_MAX_NUM_REF_FRAME_NON_AVC 4
37 #define CODEC_NUM_FIELDS_PER_FRAME 2
38 #define CODEC_MAX_NUM_REF_RECYCLE_LIST 17
39
40 #define CODEC_NUM_BLOCK_PER_MB 6 //!< Block number per MB: 4Y + Cb +Cr
41
42 // picture coding type
43 #define I_TYPE 1
44 #define P_TYPE 2
45 #define B_TYPE 3
46 #define NUM_PIC_TYPES 3
47
48 #define CODECHAL_MACROBLOCK_HEIGHT 16
49 #define CODECHAL_MACROBLOCK_WIDTH 16
50
51 #define CODECHAL_STATUS_QUERY_SKIPPED 0x00
52 #define CODECHAL_STATUS_QUERY_START_FLAG 0x01
53 #define CODECHAL_STATUS_QUERY_END_FLAG 0xFF
54
55 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_VC1 128
56 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2 128
57 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_JPEG 1
58 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8 128
59 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC 127 // 7 bits, 0x7f is invalid one
60 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP9 128
61 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_AV1 128
62
63 #define WIDTH_IN_DW(w) ((w + 0x3) >> 2)
64
65 #define ABS(a) (((a) < 0) ? (-(a)) : (a))
66 #define SIGNED(code) (2 * ABS(code) - ((code) > 0))
67
68 #define CODEC_SIZE_MFX_STREAMOUT_DATA (16 * sizeof(uint32_t))
69
70 #define ILDB_TYPE 5
71 #define OLP_TYPE 6
72 #define MIXED_TYPE 7
73 #define COPY_TYPE 7
74
75 // Pyramind B frame - used from DDI
76 #define B1_TYPE 8
77 #define B2_TYPE 9
78 #define INVALID_TYPE 10 // keep at end
79
80 #define CODECHAL_GET_ARRAY_LENGTH(a) (sizeof(a) / sizeof(a[0]))
81 #define CODECHAL_CACHELINE_SIZE 64
82 #define CODECHAL_PAGE_SIZE 0x1000
83
84 // Params for Huc
85 #define HUC_DMEM_OFFSET_RTOS_GEMS 0x2000
86 #define VDBOX_HUC_VDENC_BRC_INIT_KERNEL_DESCRIPTOR 4
87
88 #define CODEC_720P_MAX_PIC_WIDTH 1280
89 #define CODEC_720P_MAX_PIC_HEIGHT 1280
90
91 #define CODEC_MAX_PIC_WIDTH 1920
92 #define CODEC_MAX_PIC_HEIGHT 1920 // Tablet usage in portrait mode, image resolution = 1200x1920, so change MAX_HEIGHT to 1920
93
94 #define CODEC_2K_MAX_PIC_WIDTH 2048
95 #define CODEC_2K_MAX_PIC_HEIGHT 2048
96
97 #define CODEC_4K_VC1_MAX_PIC_WIDTH 3840
98 #define CODEC_4K_VC1_MAX_PIC_HEIGHT 3840
99
100 #define CODEC_4K_MAX_PIC_WIDTH 4096
101 #define CODEC_4K_MAX_PIC_HEIGHT 4096
102
103 #define CODEC_8K_MAX_PIC_WIDTH 8192
104 #define CODEC_8K_MAX_PIC_HEIGHT 8192
105
106 #define CODEC_16K_MAX_PIC_WIDTH 16384
107 #define CODEC_12K_MAX_PIC_HEIGHT 12288
108 #define CODEC_16K_MAX_PIC_HEIGHT 16384
109
110 #define CODECHAL_MAD_BUFFER_SIZE 4 // buffer size is 4 bytes
111
112 #define CODEC_128_MIN_PIC_WIDTH 128
113 #define CODEC_96_MIN_PIC_HEIGHT 96
114 #define CODEC_128_MIN_PIC_HEIGHT 128
115
116 /*! \brief Flags for various picture properties.
117 */
118 typedef enum _CODEC_PICTURE_FLAG
119 {
120 PICTURE_TOP_FIELD = 0x01,
121 PICTURE_BOTTOM_FIELD = 0x02,
122 PICTURE_FRAME = 0x04,
123 PICTURE_INTERLACED_FRAME = 0x08,
124 PICTURE_SHORT_TERM_REFERENCE = 0x10,
125 PICTURE_LONG_TERM_REFERENCE = 0x20,
126 PICTURE_UNAVAILABLE_FRAME = 0x40,
127 PICTURE_INVALID = 0x80,
128 PICTURE_RESIZE = 0xF0,
129 PICTURE_MAX_7BITS = 0xFF
130 } CODEC_PICTURE_FLAG;
131
132 /*! \brief Information pertaining to a frame's uncompressed surface
133 *
134 * Both to identify and describe the surface.
135 */
136 typedef struct _CODEC_PICTURE
137 {
138 uint8_t FrameIdx; //!< Index for the frame's uncompressed surface
139 CODEC_PICTURE_FLAG PicFlags; //!< Flags describing picture properties
140 uint8_t PicEntry; //!< Unaltered DDI frame information (for debug purposes only)
141 } CODEC_PICTURE, *PCODEC_PICTURE;
142
143 // Forward Declarations
144 typedef struct _CODEC_REF_LIST CODEC_REF_LIST, *PCODEC_REF_LIST;
145
146 // ---------------------------
147 // Enums
148 // ---------------------------
149 typedef enum
150 {
151 TOP_FIELD = 1,
152 BOTTOM_FIELD = 2,
153 FRAME_PICTURE = 3
154 } PICTURE_STRUCTURE;
155
156 //!
157 //! \enum REFLIST
158 //! \brief Reference list
159 //!
160 enum REFLIST
161 {
162 LIST_0 = 0,
163 LIST_1 = 1
164 };
165
166 //!
167 //! \enum CODECHAL_MODE
168 //! \brief Mode requested (high level combination between CODEC_STANDARD and CODEC_FUCNTION).
169 //! Note: These modes are may be used for performance tagging. Be sure to notify tool owners if changing the definitions.
170 //!
171 enum CODECHAL_MODE
172 {
173 CODECHAL_DECODE_MODE_BEGIN = 0,
174 CODECHAL_DECODE_MODE_MPEG2IDCT = 0,
175 CODECHAL_DECODE_MODE_MPEG2VLD = 1,
176 CODECHAL_DECODE_MODE_VC1IT = 2,
177 CODECHAL_DECODE_MODE_VC1VLD = 3,
178 CODECHAL_DECODE_MODE_AVCVLD = 4,
179 CODECHAL_DECODE_MODE_JPEG = 5,
180 CODECHAL_DECODE_MODE_AV1VLD = 6,
181 CODECHAL_DECODE_MODE_VP8VLD = 7,
182 CODECHAL_DECODE_MODE_HEVCVLD = 8,
183 CODECHAL_DECODE_MODE_HUC = 9,
184 CODECHAL_DECODE_RESERVED_2 = 10, // formerly AVS
185 CODECHAL_DECODE_MODE_MVCVLD = 11, // Needed for CP. Not in use by Codec HAL.
186 CODECHAL_DECODE_MODE_VP9VLD = 12,
187 CODECHAL_DECODE_MODE_CENC = 13, // Only for getting HuC-based DRM command size. Not an actual mode.
188 CODECHAL_DECODE_MODE_VVCVLD = 14,
189 CODECHAL_DECODE_MODE_RESERVED1 = 15,
190 CODECHAL_DECODE_MODE_RESERVED2 = 16,
191 CODECHAL_DECODE_MODE_END = 17,
192
193 CODECHAL_ENCODE_MODE_BEGIN = 32,
194 CODECHAL_ENCODE_MODE_AVC = 32, // Must be a power of 2 to match perf report expectations
195 CODECHAL_ENCODE_MODE_MPEG2 = 34,
196 CODECHAL_ENCODE_MODE_VP8 = 35,
197 CODECHAL_ENCODE_MODE_JPEG = 36,
198 CODECHAL_ENCODE_MODE_HEVC = 38,
199 CODECHAL_ENCODE_MODE_VP9 = 39,
200 CODECHAL_ENCODE_MODE_AV1 = 40,
201 CODECHAL_ENCODE_MODE_END = 41,
202
203 CODECHAL_Rsvd = 64,
204
205 CODECHAL_UNSUPPORTED_MODE = 96
206 };
207
208 // Slice group mask
209 typedef enum tagSLICE_GROUP_MASK
210 {
211 SLICE_GROUP_START = 0x1,
212 SLICE_GROUP_END = 0x2,
213 SLICE_GROUP_LAST = 0x4
214 } SLICE_GROUP_MASK;
215
216 typedef struct _CODEC_PIC_ID
217 {
218 uint8_t ucPicIdx;
219 uint8_t ucDMVOffset[CODEC_NUM_FIELDS_PER_FRAME]; // 0 - top field, 1 - bottom field
220 bool bValid;
221 } CODEC_PIC_ID, *PCODEC_PIC_ID;
222
223 #if defined (_AVC_ENCODE_VME_SUPPORTED) || defined (_AVC_ENCODE_VDENC_SUPPORTED)
224 struct _CODEC_AVC_REF_PIC_SELECT_LIST;
225 typedef struct _CODEC_AVC_REF_PIC_SELECT_LIST *PCODEC_AVC_REF_PIC_SELECT_LIST;
226 #endif
227
228 typedef struct _CODEC_VC1_IC
229 {
230 // Top filed
231 uint16_t wICCScale1;
232 uint16_t wICCShiftL1;
233 uint16_t wICCShiftC1;
234 // Bottom field
235 uint16_t wICCScale2;
236 uint16_t wICCShiftL2;
237 uint16_t wICCShiftC2;
238 } CODEC_VC1_IC, *PCODEC_VC1_IC;
239
240 //!
241 //! \struct _CODEC_REF_LIST
242 //! \brief Codec reference list
243 //!
244 struct _CODEC_REF_LIST
245 {
246 // Shared decoding parameters
247 CODEC_PICTURE RefPic;
248 MOS_RESOURCE resRefPic; // Resource of RefPic
249 uint8_t ucFrameId;
250 int32_t iFieldOrderCnt[CODEC_NUM_FIELDS_PER_FRAME];
251 uint8_t ucDMVIdx[CODEC_NUM_FIELDS_PER_FRAME];
252 bool bUsedAsRef;
253 uint8_t ucNumRef;
254 uint8_t ucAvcPictureCodingType; // used for PAFF case, 0: frame, 1: tff field, 2: invalid, 3: bff field
255 CODEC_PICTURE RefList[CODEC_MAX_NUM_REF_FRAME];
256 int16_t sFrameNumber;
257
258 // Shared encoding parameters
259 uint8_t ucMbCodeIdx;
260 uint8_t ucScalingIdx;
261 uint8_t ucMADBufferIdx;
262 bool bMADEnabled;
263 bool b4xScalingUsed;
264 bool b16xScalingUsed;
265 bool b32xScalingUsed;
266 bool b2xScalingUsed; // 2x scaling currently only used for HEVC CNL. Uses same surface as 32x since 32x is not supported.
267 uint8_t ucInitialIdx[2][2];
268 uint8_t ucFinalIdx[2][2];
269 uint8_t ucQPValue[2];
270 MOS_RESOURCE resBitstreamBuffer;
271 MOS_RESOURCE resRefMbCodeBuffer;
272 MOS_RESOURCE resRefMvDataBuffer;
273 MOS_SURFACE sRefBuffer;
274 MOS_SURFACE sRefReconBuffer;
275 MOS_SURFACE sRefRawBuffer;
276
277 // Codec specific parameters
278 union
279 {
280 // AVC, MVC
281 struct
282 {
283 uint16_t usNonExistingFrameFlags;
284 bool bUsedAsInterViewRef;
285 uint32_t uiUsedForReferenceFlags;
286 #if defined (_AVC_ENCODE_VME_SUPPORTED) || defined (_AVC_ENCODE_VDENC_SUPPORTED)
287 PCODEC_AVC_REF_PIC_SELECT_LIST pRefPicSelectListEntry;
288 #endif
289 MOS_RESOURCE resRefTopFieldMbCodeBuffer;
290 MOS_RESOURCE resRefBotFieldMbCodeBuffer;
291 MOS_RESOURCE resRefTopFieldMvDataBuffer;
292 MOS_RESOURCE resRefBotFieldMvDataBuffer;
293 };
294
295 // VC1
296 struct
297 {
298 uint32_t dwRefSurfaceFlags;
299 CODEC_VC1_IC Vc1IcValues[CODEC_NUM_FIELDS_PER_FRAME];
300 bool bUnequalFieldSurfaceValid;
301 uint32_t dwUnequalFieldSurfaceIdx;
302 };
303
304 // HEVC / AVC
305 struct
306 {
307 bool bIsIntra;
308 bool bFormatConversionDone;
309 uint32_t rollingIntraRefreshedPosition; // in units of blocks
310 };
311
312 // VP9
313 struct
314 {
315 MOS_SURFACE sDysSurface; // dynamic scaled surface (encoding resolution)
316 MOS_SURFACE sDys4xScaledSurface; // dynamic scaled surface (encoding resolution)
317 MOS_SURFACE sDys16xScaledSurface; // dynamic scaled surface (encoding resolution)
318 uint32_t dwFrameWidth; // in pixel
319 uint32_t dwFrameHeight; // in pixel
320 };
321 };
322 };
323
324 //!
325 //! \struct CodechalHucStreamoutParams
326 //! \brief Codechal Huc streamout parameters
327 //!
328 struct CodechalHucStreamoutParams
329 {
330 CODECHAL_MODE mode;
331
332 // Indirect object addr command params
333 PMOS_RESOURCE dataBuffer;
334 uint32_t dataSize; // 4k aligned
335 uint32_t dataOffset; // 4k aligned
336 PMOS_RESOURCE streamOutObjectBuffer;
337 uint32_t streamOutObjectSize; // 4k aligned
338 uint32_t streamOutObjectOffset; //4k aligned
339
340 // Stream object params
341 uint32_t indStreamInLength;
342 uint32_t inputRelativeOffset;
343 uint32_t outputRelativeOffset;
344
345 // Segment Info
346 void *segmentInfo;
347
348 // Indirect Security State
349 MOS_RESOURCE hucIndState;
350 uint32_t curIndEntriesNum;
351 uint32_t curNumSegments;
352 };
353
354 /*! \brief High level codec functionality
355 */
356 typedef enum _CODECHAL_FUNCTION
357 {
358 CODECHAL_FUNCTION_INVALID = 0,
359 CODECHAL_FUNCTION_DECODE = 1,
360 CODECHAL_FUNCTION_ENC = 2, // Must be a power of 2 to match perf report expectations
361 CODECHAL_FUNCTION_PAK = 4, // Must be a power of 2 to match perf report expectations
362 CODECHAL_FUNCTION_ENC_PAK = 8, // Must be a power of 2 to match perf report expectations
363 CODECHAL_FUNCTION_HYBRIDPAK = 16,
364 CODECHAL_FUNCTION_ENC_VDENC_PAK = 32,
365 CODECHAL_FUNCTION_CENC_DECODE = 64,
366 CODECHAL_FUNCTION_DEMO_COPY = 128,
367 CODECHAL_FUNCTION_FEI_PRE_ENC = 256,
368 CODECHAL_FUNCTION_FEI_ENC = 512,
369 CODECHAL_FUNCTION_FEI_PAK = 1024,
370 CODECHAL_FUNCTION_FEI_ENC_PAK = 2048
371 } CODECHAL_FUNCTION, *PCODECHAL_FUNCTION;
372
373 // TargetUsage from app - used from DDI
374 enum
375 {
376 TARGETUSAGE_UNKNOWN = 0,
377 TARGETUSAGE_BEST_QUALITY = 1,
378 TARGETUSAGE_HI_QUALITY = 2,
379 TARGETUSAGE_OPT_QUALITY = 3,
380 TARGETUSAGE_OK_QUALITY = 5,
381 TARGETUSAGE_NO_SPEED = 1,
382 TARGETUSAGE_OPT_SPEED = 3,
383 TARGETUSAGE_RT_SPEED = 4,
384 TARGETUSAGE_HI_SPEED = 6,
385 TARGETUSAGE_BEST_SPEED = 7,
386 TARGETUSAGE_LOW_LATENCY = 0x10,
387 TARGETUSAGE_MULTIPASS = 0x20
388 };
389
390 typedef enum _CODECHAL_LUMA_CHROMA_DEPTH
391 {
392 CODECHAL_LUMA_CHROMA_DEPTH_INVALID = 0x00,
393 CODECHAL_LUMA_CHROMA_DEPTH_8_BITS = 0x01,
394 CODECHAL_LUMA_CHROMA_DEPTH_10_BITS = 0x02,
395 CODECHAL_LUMA_CHROMA_DEPTH_12_BITS = 0x04
396 } CODECHAL_LUMA_CHROMA_DEPTH;
397
398 /*! \brief Status returned per picture executed by status reporting
399 */
400 typedef enum _CODECHAL_STATUS
401 {
402 /*! \brief The picture in question was processed successfully by HW
403 *
404 * All relevant parameters in the status reporting structure should be valid.
405 */
406 CODECHAL_STATUS_SUCCESSFUL = 0,
407 CODECHAL_STATUS_INCOMPLETE = 1, //!< The picture in question has not yet finished being processing on HW.
408 /*! \brief Indicates that an error occured during execution.
409 *
410 * Only error reporting parameters in the status reporting structure will be valid. This status will be returned if the workload(s) for the picture in question resulted in a HW hang or HW status indicators indicate a failure.
411 */
412 CODECHAL_STATUS_ERROR = 2,
413 CODECHAL_STATUS_UNAVAILABLE = 3, //!< Indicates that the entry in the status reporting array was not used
414 CODECHAL_STATUS_RESET = 4 //!< Indicates that Media Reset happend
415 } CODECHAL_STATUS, *PCODECHAL_STATUS;
416
417 typedef enum _CODECHAL_CHROMA_SITING_TYPE
418 {
419 CODECHAL_CHROMA_SITING_NONE = 0x00,
420 CODECHAL_CHROMA_SITING_HORZ_LEFT = 0x01,
421 CODECHAL_CHROMA_SITING_HORZ_CENTER = 0x02,
422 CODECHAL_CHROMA_SITING_HORZ_RIGHT = 0x04,
423 CODECHAL_CHROMA_SITING_VERT_TOP = 0x10,
424 CODECHAL_CHROMA_SITING_VERT_CENTER = 0x20,
425 CODECHAL_CHROMA_SITING_VERT_BOTTOM = 0x40
426 } CODECHAL_CHROMA_SITING_TYPE;
427
428 typedef enum _CODECHAL_CHROMA_SUBSAMPLING
429 {
430 CODECHAL_CHROMA_SUBSAMPLING_TOP_CENTER = 0,
431 CODECHAL_CHROMA_SUBSAMPLING_CENTER_CENTER,
432 CODECHAL_CHROMA_SUBSAMPLING_BOTTOM_CENTER,
433 CODECHAL_CHROMA_SUBSAMPLING_TOP_LEFT,
434 CODECHAL_CHROMA_SUBSAMPLING_CENTER_LEFT,
435 CODECHAL_CHROMA_SUBSAMPLING_BOTTOM_LEFT
436 } CODECHAL_CHROMA_SUBSAMPLING;
437
438 typedef enum _CODECHAL_MEDIA_STATE_TYPE
439 {
440 CODECHAL_MEDIA_STATE_OLP = 0,
441 CODECHAL_MEDIA_STATE_ENC_NORMAL = 1,
442 CODECHAL_MEDIA_STATE_ENC_PERFORMANCE = 2,
443 CODECHAL_MEDIA_STATE_ENC_QUALITY = 3,
444 CODECHAL_MEDIA_STATE_ENC_I_FRAME_DIST = 4,
445 CODECHAL_MEDIA_STATE_32X_SCALING = 5,
446 CODECHAL_MEDIA_STATE_16X_SCALING = 6,
447 CODECHAL_MEDIA_STATE_4X_SCALING = 7,
448 CODECHAL_MEDIA_STATE_32X_ME = 8,
449 CODECHAL_MEDIA_STATE_16X_ME = 9,
450 CODECHAL_MEDIA_STATE_4X_ME = 10,
451 CODECHAL_MEDIA_STATE_BRC_INIT_RESET = 11,
452 CODECHAL_MEDIA_STATE_BRC_UPDATE = 12,
453 CODECHAL_MEDIA_STATE_BRC_BLOCK_COPY = 13,
454 CODECHAL_MEDIA_STATE_HYBRID_PAK_P1 = 14,
455 CODECHAL_MEDIA_STATE_HYBRID_PAK_P2 = 15,
456 CODECHAL_MEDIA_STATE_ENC_I_FRAME_CHROMA = 16,
457 CODECHAL_MEDIA_STATE_ENC_I_FRAME_LUMA = 17,
458 CODECHAL_MEDIA_STATE_MPU_FHB = 18,
459 CODECHAL_MEDIA_STATE_TPU_FHB = 19,
460 CODECHAL_MEDIA_STATE_PA_COPY = 20,
461 CODECHAL_MEDIA_STATE_PL2_COPY = 21,
462 CODECHAL_MEDIA_STATE_ENC_ADV = 22,
463 CODECHAL_MEDIA_STATE_2X_SCALING = 23,
464 CODECHAL_MEDIA_STATE_32x32_PU_MODE_DECISION = 24,
465 CODECHAL_MEDIA_STATE_16x16_PU_SAD = 25,
466 CODECHAL_MEDIA_STATE_16x16_PU_MODE_DECISION = 26,
467 CODECHAL_MEDIA_STATE_8x8_PU = 27,
468 CODECHAL_MEDIA_STATE_8x8_PU_FMODE = 28,
469 CODECHAL_MEDIA_STATE_32x32_B_INTRA_CHECK = 29,
470 CODECHAL_MEDIA_STATE_HEVC_B_MBENC = 30,
471 CODECHAL_MEDIA_STATE_RESET_VLINE_STRIDE = 31,
472 CODECHAL_MEDIA_STATE_HEVC_B_PAK = 32,
473 CODECHAL_MEDIA_STATE_HEVC_BRC_LCU_UPDATE = 33,
474 CODECHAL_MEDIA_STATE_ME_VDENC_STREAMIN = 34,
475 CODECHAL_MEDIA_STATE_VP9_ENC_I_32x32 = 35,
476 CODECHAL_MEDIA_STATE_VP9_ENC_I_16x16 = 36,
477 CODECHAL_MEDIA_STATE_VP9_ENC_P = 37,
478 CODECHAL_MEDIA_STATE_VP9_ENC_TX = 38,
479 CODECHAL_MEDIA_STATE_VP9_DYS = 39,
480 CODECHAL_MEDIA_STATE_VP9_PAK_LUMA_RECON = 40,
481 CODECHAL_MEDIA_STATE_VP9_PAK_CHROMA_RECON = 41,
482 CODECHAL_MEDIA_STATE_VP9_PAK_DEBLOCK_MASK = 42,
483 CODECHAL_MEDIA_STATE_VP9_PAK_LUMA_DEBLOCK = 43,
484 CODECHAL_MEDIA_STATE_VP9_PAK_CHROMA_DEBLOCK = 44,
485 CODECHAL_MEDIA_STATE_VP9_PAK_MC_PRED = 45,
486 CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_LUMA_RECON = 46,
487 CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_LUMA_RECON_32x32 = 47,
488 CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_CHROMA_RECON = 48,
489 CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_INTRA_LUMA_RECON = 49,
490 CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_INTRA_CHROMA_RECON = 50,
491 CODECHAL_MEDIA_STATE_PREPROC = 51,
492 CODECHAL_MEDIA_STATE_ENC_WP = 52,
493 CODECHAL_MEDIA_STATE_HEVC_I_MBENC = 53,
494 CODECHAL_MEDIA_STATE_CSC_DS_COPY = 54,
495 CODECHAL_MEDIA_STATE_2X_4X_SCALING = 55,
496 CODECHAL_MEDIA_STATE_HEVC_LCU64_B_MBENC = 56,
497 CODECHAL_MEDIA_STATE_MB_BRC_UPDATE = 57,
498 CODECHAL_MEDIA_STATE_STATIC_FRAME_DETECTION = 58,
499 CODECHAL_MEDIA_STATE_HEVC_ROI = 59,
500 CODECHAL_MEDIA_STATE_SW_SCOREBOARD_INIT = 60,
501 CODECHAL_NUM_MEDIA_STATES = 61
502 } CODECHAL_MEDIA_STATE_TYPE;
503 C_ASSERT(CODECHAL_NUM_MEDIA_STATES == CODECHAL_MEDIA_STATE_SW_SCOREBOARD_INIT + 1); //!< update this and add new entry in the default SSEU table for each platform()
504
505
506 #define CODECHAL_OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
507 #define CODECHAL_OFFSETOF_IN_DW(TYPE, ELEMENT) (CODECHAL_OFFSETOF(TYPE, ELEMENT) >> 2)
508 #define CODECHAL_ADDROF_TYPE(TYPE, ELEMENT, ELEMENT_ADDR) ((TYPE *)((uint8_t *)(ELEMENT_ADDR) - CODECHAL_OFFSETOF(TYPE, ELEMENT)))
509
510 #define CODECHAL_GET_WIDTH_IN_MACROBLOCKS(dwWidth) (((dwWidth) + (CODECHAL_MACROBLOCK_WIDTH - 1)) / CODECHAL_MACROBLOCK_WIDTH)
511 #define CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(dwHeight) (((dwHeight) + (CODECHAL_MACROBLOCK_HEIGHT - 1)) / CODECHAL_MACROBLOCK_HEIGHT)
512 #define CODECHAL_GET_WIDTH_IN_BLOCKS(dwWidth, dwBlockSize) (((dwWidth) + (dwBlockSize - 1)) / dwBlockSize)
513 #define CODECHAL_GET_HEIGHT_IN_BLOCKS(dwHeight, dwBlockSize) (((dwHeight) + (dwBlockSize - 1)) / dwBlockSize)
514 #define CODECHAL_GET_4xDS_SIZE_32ALIGNED(dwSize) ((((dwSize >> 2) + 31) >> 5) << 5)
515 #define CODECHAL_GET_2xDS_SIZE_32ALIGNED(dwSize) ((((dwSize >> 1) + 31) >> 5) << 5)
516
517 // Macros to determin CODEC_PICTURE_FLAG meaning
518 #define CodecHal_PictureIsTopField(Pic) (((Pic).PicFlags & PICTURE_TOP_FIELD) != 0)
519 #define CodecHal_PictureIsBottomField(Pic) (((Pic).PicFlags & PICTURE_BOTTOM_FIELD) != 0)
520 #define CodecHal_PictureIsField(pic) \
521 ((CodecHal_PictureIsTopField((pic)) || CodecHal_PictureIsBottomField((pic))) != 0)
522 #define CodecHal_PictureIsFrame(Pic) (((Pic).PicFlags & PICTURE_FRAME) != 0)
523 #define CodecHal_PictureIsInterlacedFrame(Pic) (((Pic).PicFlags & PICTURE_INTERLACED_FRAME) != 0)
524 #define CodecHal_PictureIsLongTermRef(Pic) (((Pic).PicFlags & PICTURE_LONG_TERM_REFERENCE) != 0)
525 #define CodecHal_PictureIsShortTermRef(Pic) (((Pic).PicFlags & PICTURE_SHORT_TERM_REFERENCE) != 0)
526 #define CodecHal_PictureIsInvalid(Pic) (((Pic).PicFlags & PICTURE_INVALID) != 0)
527
528 #define CodecHal_GetFrameFieldHeightInMb(pic, heightInMb, adjustedHeightInMb) \
529 { \
530 if(CodecHal_PictureIsField((pic))) \
531 { \
532 adjustedHeightInMb = ((heightInMb) + 1) >> 1; \
533 } \
534 else \
535 { \
536 adjustedHeightInMb = (heightInMb); \
537 } \
538 }
539
540 #define CodecHalIsDecode(codecFunction) \
541 (codecFunction == CODECHAL_FUNCTION_DECODE || \
542 codecFunction == CODECHAL_FUNCTION_CENC_DECODE)
543
544 #define CodecHalIsDecodeModeVLD(mode) \
545 ((mode == CODECHAL_DECODE_MODE_MPEG2VLD) || \
546 (mode == CODECHAL_DECODE_MODE_VC1VLD) || \
547 (mode == CODECHAL_DECODE_MODE_AVCVLD) || \
548 (mode == CODECHAL_DECODE_MODE_JPEG) || \
549 (mode == CODECHAL_DECODE_MODE_VP8VLD) || \
550 (mode == CODECHAL_DECODE_MODE_HEVCVLD) || \
551 (mode == CODECHAL_DECODE_MODE_VP9VLD))
552
553 #define CodecHalIsDecodeModeIT(mode) \
554 ((mode == CODECHAL_DECODE_MODE_MPEG2IDCT) || \
555 (mode == CODECHAL_DECODE_MODE_VC1IT))
556
557 #define CodecHal_CombinePictureFlags(originalPic, newPic) \
558 ((CODEC_PICTURE_FLAG)((((uint32_t)(originalPic).PicFlags) & 0xF) | ((uint32_t)(newPic).PicFlags)))
559
560 #define CodecHalIsEnableFieldScaling(codecFunction, standard, hint) \
561 ((codecFunction == CODECHAL_FUNCTION_DECODE) && \
562 (standard == CODECHAL_AVC) && \
563 (hint == true))
564
565 #define CodecHalDecodeMapGpuNodeToGpuContex(gpuNode, gpuCtxt, wactx)\
566 do \
567 { \
568 switch (gpuNode) \
569 { \
570 case MOS_GPU_NODE_VIDEO: \
571 gpuCtxt = wactx ? MOS_GPU_CONTEXT_VIDEO2 : MOS_GPU_CONTEXT_VIDEO; \
572 break; \
573 case MOS_GPU_NODE_VIDEO2: \
574 gpuCtxt = wactx ? MOS_GPU_CONTEXT_VDBOX2_VIDEO2 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;\
575 break; \
576 default: \
577 gpuCtxt = wactx ? MOS_GPU_CONTEXT_VIDEO2 : MOS_GPU_CONTEXT_VIDEO; \
578 CODECHAL_DECODE_ASSERTMESSAGE("invalid GPU NODE value."); \
579 break; \
580 } \
581 }while (0)
582
583 #define CodecHalDecode1stHcpDecPhaseInSinglePipeMode(hcpDecPhase, shortFormat)\
584 ((hcpDecPhase == CodechalDecode::CodechalHcpDecodePhaseLegacyS2L && shortFormat) || \
585 (hcpDecPhase == CodechalDecode::CodechalHcpDecodePhaseLegacyLong && !shortFormat))
586
587 //| HW parameter initializers
588 const MOS_SYNC_PARAMS g_cInitSyncParams =
589 {
590 MOS_GPU_CONTEXT_RENDER, // GpuContext
591 nullptr, // presSyncResource
592 1, // uiSemaphoreCount
593 0, // uiSemaphoreValue
594 0, // uiSemaphoreOffset
595 false, // bReadOnly
596 true, // bDisableDecodeSyncLock
597 false, // bDisableLockForTranscode
598 };
599
600 // ---------------------------
601 // Functions
602 // ---------------------------
GetReciprocalScalingValue(uint8_t scaleValue)603 static __inline uint16_t GetReciprocalScalingValue(uint8_t scaleValue)
604 {
605 uint16_t reciprocalScaleValue;
606 if (scaleValue < 2)
607 {
608 reciprocalScaleValue = 0xffff;
609 }
610 else
611 {
612 reciprocalScaleValue = (4096 * 16)/scaleValue;
613 }
614
615 return reciprocalScaleValue;
616 }
617
618 // this function covert the input value v to A|B format so v~=B*pow(2, A);
Map44LutValue(uint32_t v,uint8_t max)619 static __inline uint8_t Map44LutValue(uint32_t v, uint8_t max)
620 {
621 uint32_t maxCost;
622 int D;
623 uint8_t ret;
624
625 if (v == 0)
626 {
627 return 0;
628 }
629
630 maxCost = ((max & 15) << (max >> 4));
631 if (v >= maxCost)
632 {
633 return max;
634 }
635
636 D = (int)(log((double)v) / log(2.)) - 3;
637 if (D < 0)
638 {
639 D = 0;
640 }
641
642 ret = (uint8_t)((D << 4) + (int)((v + (D == 0 ? 0 : (1 << (D - 1)))) >> D));
643 ret = (ret & 0xf) == 0 ? (ret | 8) : ret;
644
645 return ret;
646 }
647
GetU62ModeCost(double mcost)648 static __inline uint8_t GetU62ModeCost(double mcost)
649 {
650 return (uint8_t)(mcost * 4 + 0.5);
651 }
652
GetU71ModeCost(double mcost)653 static __inline uint8_t GetU71ModeCost(double mcost)
654 {
655 return (uint8_t)(mcost * 2 + 0.5);
656 }
657
GetU44ModeCost(double mcost)658 static __inline uint8_t GetU44ModeCost(double mcost)
659 {
660 return (uint8_t)(mcost * 16 + 0.5);
661 }
662
LimNumBits(uint8_t cost,int32_t numBits)663 static __inline uint8_t LimNumBits(uint8_t cost, int32_t numBits)
664 {
665 int32_t startBit = -1;
666
667 for (int i = 7; i >= numBits; i--)
668 {
669 if ((cost >> i) != 0)
670 {
671 startBit = i;
672 }
673 }
674
675 if (startBit >= 0)
676 {
677 cost = ((cost >> (startBit - numBits + 1)) << (startBit - numBits + 1));
678 }
679
680 return cost;
681 }
682
CodecHal_GetStandardFromMode(uint32_t mode)683 static __inline uint32_t CodecHal_GetStandardFromMode(uint32_t mode)
684 {
685 uint32_t standard = CODECHAL_UNDEFINED;
686
687 switch (mode)
688 {
689 case CODECHAL_DECODE_MODE_MPEG2IDCT:
690 case CODECHAL_DECODE_MODE_MPEG2VLD:
691 case CODECHAL_ENCODE_MODE_MPEG2:
692 standard = CODECHAL_MPEG2;
693 break;
694 case CODECHAL_DECODE_MODE_VC1IT:
695 case CODECHAL_DECODE_MODE_VC1VLD:
696 standard = CODECHAL_VC1;
697 break;
698 case CODECHAL_DECODE_MODE_AVCVLD:
699 case CODECHAL_ENCODE_MODE_AVC:
700 standard = CODECHAL_AVC;
701 break;
702 case CODECHAL_DECODE_MODE_JPEG:
703 case CODECHAL_ENCODE_MODE_JPEG:
704 standard = CODECHAL_JPEG;
705 break;
706 case CODECHAL_DECODE_MODE_VP8VLD:
707 case CODECHAL_ENCODE_MODE_VP8:
708 standard = CODECHAL_VP8;
709 break;
710 case CODECHAL_DECODE_MODE_HEVCVLD:
711 case CODECHAL_ENCODE_MODE_HEVC:
712 standard = CODECHAL_HEVC;
713 break;
714 case CODECHAL_ENCODE_MODE_VP9:
715 case CODECHAL_DECODE_MODE_VP9VLD:
716 standard = CODECHAL_VP9;
717 break;
718 case CODECHAL_DECODE_MODE_CENC:
719 standard = CODECHAL_CENC;
720 break;
721 case CODECHAL_ENCODE_MODE_AV1:
722 standard = CODECHAL_AV1;
723 break;
724 default:
725 standard = CODECHAL_UNDEFINED;
726 break;
727 }
728
729 return standard;
730 }
731
CodecHal_Clip3(int x,int y,int z)732 static __inline int32_t CodecHal_Clip3(int x, int y, int z)
733 {
734 int32_t ret = 0;
735
736 if (z < x)
737 {
738 ret = x;
739 }
740 else if (z > y)
741 {
742 ret = y;
743 }
744 else
745 {
746 ret = z;
747 }
748
749 return ret;
750 }
751
CeilLog2(uint32_t value)752 static __inline uint32_t CeilLog2(uint32_t value)
753 {
754 uint32_t res = 0;
755
756 while (value > (uint32_t)(1 << res)) res++;
757
758 return res;
759 }
760
761 #endif // __CODEC_DEF_COMMON_H__
762