1 /*
2 * Copyright (c) 2017-2021, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file 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 <math.h>
33
34 #define CODEC_MAX_NUM_REF_FRAME 16
35 #define CODEC_MAX_NUM_REF_FRAME_NON_AVC 4
36 #define CODEC_NUM_FIELDS_PER_FRAME 2
37 #define CODEC_MAX_NUM_REF_RECYCLE_LIST 17
38
39 #define CODEC_NUM_BLOCK_PER_MB 6 //!< Block number per MB: 4Y + Cb +Cr
40
41 // picture coding type
42 #define I_TYPE 1
43 #define P_TYPE 2
44 #define B_TYPE 3
45 #define NUM_PIC_TYPES 3
46
47 #define CODECHAL_MACROBLOCK_HEIGHT 16
48 #define CODECHAL_MACROBLOCK_WIDTH 16
49
50 #define CODECHAL_STATUS_QUERY_SKIPPED 0x00
51 #define CODECHAL_STATUS_QUERY_START_FLAG 0x01
52 #define CODECHAL_STATUS_QUERY_END_FLAG 0xFF
53
54 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_VC1 128
55 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2 128
56 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_JPEG 1
57 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8 128
58 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC 127 // 7 bits, 0x7f is invalid one
59 #define CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP9 128
60
61 #define WIDTH_IN_DW(w) ((w + 0x3) >> 2)
62
63 #define ABS(a) (((a) < 0) ? (-(a)) : (a))
64 #define SIGNED(code) (2 * ABS(code) - ((code) > 0))
65
66 #define CODEC_SIZE_MFX_STREAMOUT_DATA (16 * sizeof(uint32_t))
67
68 #define ILDB_TYPE 5
69 #define OLP_TYPE 6
70 #define MIXED_TYPE 7
71 #define COPY_TYPE 7
72
73 // Pyramind B frame - used from DDI
74 #define B1_TYPE 8
75 #define B2_TYPE 9
76 #define INVALID_TYPE 10 // keep at end
77
78 #define CODECHAL_GET_ARRAY_LENGTH(a) (sizeof(a) / sizeof(a[0]))
79
80 /*! \brief Flags for various picture properties.
81 */
82 typedef enum _CODEC_PICTURE_FLAG
83 {
84 PICTURE_TOP_FIELD = 0x01,
85 PICTURE_BOTTOM_FIELD = 0x02,
86 PICTURE_FRAME = 0x04,
87 PICTURE_INTERLACED_FRAME = 0x08,
88 PICTURE_SHORT_TERM_REFERENCE = 0x10,
89 PICTURE_LONG_TERM_REFERENCE = 0x20,
90 PICTURE_RESERVED0 = 0x40,
91 PICTURE_INVALID = 0x80,
92 PICTURE_RESIZE = 0xF0,
93 PICTURE_MAX_7BITS = 0xFF
94 } CODEC_PICTURE_FLAG;
95
96 /*! \brief Information pertaining to a frame's uncompressed surface
97 *
98 * Both to identify and describe the surface.
99 */
100 typedef struct _CODEC_PICTURE
101 {
102 uint8_t FrameIdx; //!< Index for the frame's uncompressed surface
103 CODEC_PICTURE_FLAG PicFlags; //!< Flags describing picture properties
104 uint8_t PicEntry; //!< Unaltered DDI frame information (for debug purposes only)
105 } CODEC_PICTURE, *PCODEC_PICTURE;
106
107 // Forward Declarations
108 typedef struct _CODEC_REF_LIST CODEC_REF_LIST, *PCODEC_REF_LIST;
109
110 // ---------------------------
111 // Enums
112 // ---------------------------
113 typedef enum
114 {
115 TOP_FIELD = 1,
116 BOTTOM_FIELD = 2,
117 FRAME_PICTURE = 3
118 } PICTURE_STRUCTURE;
119
120 //!
121 //! \enum REFLIST
122 //! \brief Reference list
123 //!
124 enum REFLIST
125 {
126 LIST_0 = 0,
127 LIST_1 = 1
128 };
129
130 //!
131 //! \enum CODECHAL_STANDARD
132 //! \brief Codec standard
133 //!
134 enum CODECHAL_STANDARD
135 {
136 // MFX/MFL pipeline
137 CODECHAL_MPEG2 = 0,
138 CODECHAL_VC1 = 1,
139 CODECHAL_AVC = 2,
140 CODECHAL_JPEG = 3,
141 CODECHAL_RESERVED = 4, //formerly SVC
142 CODECHAL_VP8 = 5,
143 CODECHAL_UNDEFINED = 9,
144
145 // Cenc Decode
146 CODECHAL_CENC = 63,
147
148 // HCP pipeline
149 CODECHAL_HCP_BASE = 64,
150 CODECHAL_HEVC = CODECHAL_HCP_BASE,
151 CODECHAL_VP9 = CODECHAL_HCP_BASE + 1,
152
153 //AVP pipeline
154 CODECHAL_AVP_BASE = CODECHAL_HCP_BASE + 2,
155 CODECHAL_AV1 = CODECHAL_AVP_BASE,
156
157 CODECHAL_RESERVED0,
158 CODECHAL_RESERVED1,
159 CODECHAL_STANDARD_MAX
160 };
161
162 //!
163 //! \enum CODECHAL_MODE
164 //! \brief Mode requested (high level combination between CODEC_STANDARD and CODEC_FUCNTION).
165 //! Note: These modes are may be used for performance tagging. Be sure to notify tool owners if changing the definitions.
166 //!
167 enum CODECHAL_MODE
168 {
169 CODECHAL_DECODE_MODE_MPEG2IDCT = 0,
170 CODECHAL_DECODE_MODE_MPEG2VLD = 1,
171 CODECHAL_DECODE_MODE_VC1IT = 2,
172 CODECHAL_DECODE_MODE_VC1VLD = 3,
173 CODECHAL_DECODE_MODE_AVCVLD = 4,
174 CODECHAL_DECODE_MODE_JPEG = 5,
175 CODECHAL_DECODE_MODE_AV1VLD = 6,
176 CODECHAL_DECODE_MODE_VP8VLD = 7,
177 CODECHAL_DECODE_MODE_HEVCVLD = 8,
178 CODECHAL_DECODE_MODE_HUC = 9,
179 CODECHAL_DECODE_RESERVED_2 = 10, // formerly AVS
180 CODECHAL_DECODE_MODE_MVCVLD = 11, // Needed for CP. Not in use by Codec HAL.
181 CODECHAL_DECODE_MODE_VP9VLD = 12,
182 CODECHAL_DECODE_MODE_CENC = 13, // Only for getting HuC-based DRM command size. Not an actual mode.
183 CODECHAL_DECODE_MODE_RESERVED0 = 14,
184 CODECHAL_NUM_DECODE_MODES = 15,
185
186 CODECHAL_ENCODE_MODE_AVC = 16, // Must be a power of 2 to match perf report expectations
187 CODECHAL_ENCODE_MODE_MPEG2 = 18,
188 CODECHAL_ENCODE_MODE_VP8 = 19,
189 CODECHAL_ENCODE_MODE_JPEG = 20,
190 CODECHAL_ENCODE_MODE_HEVC = 22,
191 CODECHAL_ENCODE_MODE_VP9 = 23,
192 CODECHAL_ENCODE_RESERVED_0 = 24,
193 CODECHAL_NUM_ENCODE_MODES = 8,
194
195 CODECHAL_NUM_MODES = 25, // Use the value for the last encode mode to determine this
196 CODECHAL_UNSUPPORTED_MODE = 25,
197 CODECHAL_MODE_MAX = 25
198 };
199
200 // Slice group mask
201 typedef enum tagSLICE_GROUP_MASK
202 {
203 SLICE_GROUP_START = 0x1,
204 SLICE_GROUP_END = 0x2,
205 SLICE_GROUP_LAST = 0x4
206 } SLICE_GROUP_MASK;
207
208 typedef struct _CODEC_PIC_ID
209 {
210 uint8_t ucPicIdx;
211 uint8_t ucDMVOffset[CODEC_NUM_FIELDS_PER_FRAME]; // 0 - top field, 1 - bottom field
212 bool bValid;
213 } CODEC_PIC_ID, *PCODEC_PIC_ID;
214
215 #if defined (_AVC_ENCODE_VME_SUPPORTED) || defined (_AVC_ENCODE_VDENC_SUPPORTED)
216 struct _CODEC_AVC_REF_PIC_SELECT_LIST;
217 typedef struct _CODEC_AVC_REF_PIC_SELECT_LIST *PCODEC_AVC_REF_PIC_SELECT_LIST;
218 #endif
219
220 typedef struct _CODEC_VC1_IC
221 {
222 // Top filed
223 uint16_t wICCScale1;
224 uint16_t wICCShiftL1;
225 uint16_t wICCShiftC1;
226 // Bottom field
227 uint16_t wICCScale2;
228 uint16_t wICCShiftL2;
229 uint16_t wICCShiftC2;
230 } CODEC_VC1_IC, *PCODEC_VC1_IC;
231
232 //!
233 //! \struct _CODEC_REF_LIST
234 //! \brief Codec reference list
235 //!
236 struct _CODEC_REF_LIST
237 {
238 // Shared decoding parameters
239 CODEC_PICTURE RefPic;
240 MOS_RESOURCE resRefPic; // Resource of RefPic
241 uint8_t ucFrameId;
242 int32_t iFieldOrderCnt[CODEC_NUM_FIELDS_PER_FRAME];
243 uint8_t ucDMVIdx[CODEC_NUM_FIELDS_PER_FRAME];
244 bool bUsedAsRef;
245 uint8_t ucNumRef;
246 uint8_t ucAvcPictureCodingType; // used for PAFF case, 0: frame, 1: tff field, 2: invalid, 3: bff field
247 CODEC_PICTURE RefList[CODEC_MAX_NUM_REF_FRAME];
248 int16_t sFrameNumber;
249
250 // Shared encoding parameters
251 uint8_t ucMbCodeIdx;
252 uint8_t ucScalingIdx;
253 uint8_t ucMADBufferIdx;
254 bool bMADEnabled;
255 bool b4xScalingUsed;
256 bool b16xScalingUsed;
257 bool b32xScalingUsed;
258 bool b2xScalingUsed; // 2x scaling currently only used for HEVC CNL. Uses same surface as 32x since 32x is not supported.
259 uint8_t ucInitialIdx[2][2];
260 uint8_t ucFinalIdx[2][2];
261 uint8_t ucQPValue[2];
262 MOS_RESOURCE resBitstreamBuffer;
263 MOS_RESOURCE resRefMbCodeBuffer;
264 MOS_RESOURCE resRefMvDataBuffer;
265 MOS_SURFACE sRefBuffer;
266 MOS_SURFACE sRefReconBuffer;
267 MOS_SURFACE sRefRawBuffer;
268
269 // Codec specific parameters
270 union
271 {
272 // AVC, MVC
273 struct
274 {
275 uint16_t usNonExistingFrameFlags;
276 bool bUsedAsInterViewRef;
277 uint32_t uiUsedForReferenceFlags;
278 #if defined (_AVC_ENCODE_VME_SUPPORTED) || defined (_AVC_ENCODE_VDENC_SUPPORTED)
279 PCODEC_AVC_REF_PIC_SELECT_LIST pRefPicSelectListEntry;
280 #endif
281 MOS_RESOURCE resRefTopFieldMbCodeBuffer;
282 MOS_RESOURCE resRefBotFieldMbCodeBuffer;
283 MOS_RESOURCE resRefTopFieldMvDataBuffer;
284 MOS_RESOURCE resRefBotFieldMvDataBuffer;
285 };
286
287 // VC1
288 struct
289 {
290 uint32_t dwRefSurfaceFlags;
291 CODEC_VC1_IC Vc1IcValues[CODEC_NUM_FIELDS_PER_FRAME];
292 bool bUnequalFieldSurfaceValid;
293 uint32_t dwUnequalFieldSurfaceIdx;
294 };
295
296 // HEVC / AVC
297 struct
298 {
299 bool bIsIntra;
300 bool bFormatConversionDone;
301 uint32_t rollingIntraRefreshedPosition; // in units of blocks
302 };
303
304 // VP9
305 struct
306 {
307 MOS_SURFACE sDysSurface; // dynamic scaled surface (encoding resolution)
308 MOS_SURFACE sDys4xScaledSurface; // dynamic scaled surface (encoding resolution)
309 MOS_SURFACE sDys16xScaledSurface; // dynamic scaled surface (encoding resolution)
310 uint32_t dwFrameWidth; // in pixel
311 uint32_t dwFrameHeight; // in pixel
312 };
313 };
314 };
315
316 /*! \brief High level codec functionality
317 */
318 typedef enum _CODECHAL_FUNCTION
319 {
320 CODECHAL_FUNCTION_INVALID = 0,
321 CODECHAL_FUNCTION_DECODE = 1,
322 CODECHAL_FUNCTION_ENC = 2, // Must be a power of 2 to match perf report expectations
323 CODECHAL_FUNCTION_PAK = 4, // Must be a power of 2 to match perf report expectations
324 CODECHAL_FUNCTION_ENC_PAK = 8, // Must be a power of 2 to match perf report expectations
325 CODECHAL_FUNCTION_HYBRIDPAK = 16,
326 CODECHAL_FUNCTION_ENC_VDENC_PAK = 32,
327 CODECHAL_FUNCTION_CENC_DECODE = 64,
328 CODECHAL_FUNCTION_DEMO_COPY = 128,
329 CODECHAL_FUNCTION_FEI_PRE_ENC = 256,
330 CODECHAL_FUNCTION_FEI_ENC = 512,
331 CODECHAL_FUNCTION_FEI_PAK = 1024,
332 CODECHAL_FUNCTION_FEI_ENC_PAK = 2048
333 } CODECHAL_FUNCTION, *PCODECHAL_FUNCTION;
334
335 // TargetUsage from app - used from DDI
336 enum
337 {
338 TARGETUSAGE_UNKNOWN = 0,
339 TARGETUSAGE_BEST_QUALITY = 1,
340 TARGETUSAGE_HI_QUALITY = 2,
341 TARGETUSAGE_OPT_QUALITY = 3,
342 TARGETUSAGE_OK_QUALITY = 5,
343 TARGETUSAGE_NO_SPEED = 1,
344 TARGETUSAGE_OPT_SPEED = 3,
345 TARGETUSAGE_RT_SPEED = 4,
346 TARGETUSAGE_HI_SPEED = 6,
347 TARGETUSAGE_BEST_SPEED = 7,
348 TARGETUSAGE_LOW_LATENCY = 0x10,
349 TARGETUSAGE_MULTIPASS = 0x20
350 };
351
352 typedef enum _CODECHAL_LUMA_CHROMA_DEPTH
353 {
354 CODECHAL_LUMA_CHROMA_DEPTH_INVALID = 0x00,
355 CODECHAL_LUMA_CHROMA_DEPTH_8_BITS = 0x01,
356 CODECHAL_LUMA_CHROMA_DEPTH_10_BITS = 0x02,
357 CODECHAL_LUMA_CHROMA_DEPTH_12_BITS = 0x04
358 } CODECHAL_LUMA_CHROMA_DEPTH;
359
360 /*! \brief Status returned per picture executed by status reporting
361 */
362 typedef enum _CODECHAL_STATUS
363 {
364 /*! \brief The picture in question was processed successfully by HW
365 *
366 * All relevant parameters in the status reporting structure should be valid.
367 */
368 CODECHAL_STATUS_SUCCESSFUL = 0,
369 CODECHAL_STATUS_INCOMPLETE = 1, //!< The picture in question has not yet finished being processing on HW.
370 /*! \brief Indicates that an error occured during execution.
371 *
372 * 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.
373 */
374 CODECHAL_STATUS_ERROR = 2,
375 CODECHAL_STATUS_UNAVAILABLE = 3 //!< Indicates that the entry in the status reporting array was not used
376 } CODECHAL_STATUS, *PCODECHAL_STATUS;
377
378 typedef enum _CODECHAL_SCALING_MODE
379 {
380 CODECHAL_SCALING_NEAREST = 0,
381 CODECHAL_SCALING_BILINEAR,
382 CODECHAL_SCALING_AVS,
383 CODECHAL_SCALING_ADV_QUALITY // !< Advance Perf mode
384 } CODECHAL_SCALING_MODE;
385
386 typedef enum _CODECHAL_CHROMA_SITING_TYPE
387 {
388 CODECHAL_CHROMA_SITING_NONE = 0x00,
389 CODECHAL_CHROMA_SITING_HORZ_LEFT = 0x01,
390 CODECHAL_CHROMA_SITING_HORZ_CENTER = 0x02,
391 CODECHAL_CHROMA_SITING_HORZ_RIGHT = 0x04,
392 CODECHAL_CHROMA_SITING_VERT_TOP = 0x10,
393 CODECHAL_CHROMA_SITING_VERT_CENTER = 0x20,
394 CODECHAL_CHROMA_SITING_VERT_BOTTOM = 0x40
395 } CODECHAL_CHROMA_SITING_TYPE;
396
397 typedef enum _CODECHAL_CHROMA_SUBSAMPLING
398 {
399 CODECHAL_CHROMA_SUBSAMPLING_TOP_CENTER = 0,
400 CODECHAL_CHROMA_SUBSAMPLING_CENTER_CENTER,
401 CODECHAL_CHROMA_SUBSAMPLING_BOTTOM_CENTER,
402 CODECHAL_CHROMA_SUBSAMPLING_TOP_LEFT,
403 CODECHAL_CHROMA_SUBSAMPLING_CENTER_LEFT,
404 CODECHAL_CHROMA_SUBSAMPLING_BOTTOM_LEFT
405 } CODECHAL_CHROMA_SUBSAMPLING;
406
407 #define CODECHAL_OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
408 #define CODECHAL_OFFSETOF_IN_DW(TYPE, ELEMENT) (CODECHAL_OFFSETOF(TYPE, ELEMENT) >> 2)
409 #define CODECHAL_ADDROF_TYPE(TYPE, ELEMENT, ELEMENT_ADDR) ((TYPE *)((uint8_t *)(ELEMENT_ADDR) - CODECHAL_OFFSETOF(TYPE, ELEMENT)))
410
411 #define CODECHAL_GET_WIDTH_IN_MACROBLOCKS(dwWidth) (((dwWidth) + (CODECHAL_MACROBLOCK_WIDTH - 1)) / CODECHAL_MACROBLOCK_WIDTH)
412 #define CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(dwHeight) (((dwHeight) + (CODECHAL_MACROBLOCK_HEIGHT - 1)) / CODECHAL_MACROBLOCK_HEIGHT)
413 #define CODECHAL_GET_WIDTH_IN_BLOCKS(dwWidth, dwBlockSize) (((dwWidth) + (dwBlockSize - 1)) / dwBlockSize)
414 #define CODECHAL_GET_HEIGHT_IN_BLOCKS(dwHeight, dwBlockSize) (((dwHeight) + (dwBlockSize - 1)) / dwBlockSize)
415 #define CODECHAL_GET_4xDS_SIZE_32ALIGNED(dwSize) ((((dwSize >> 2) + 31) >> 5) << 5)
416 #define CODECHAL_GET_2xDS_SIZE_32ALIGNED(dwSize) ((((dwSize >> 1) + 31) >> 5) << 5)
417
418 // Macros to determin CODEC_PICTURE_FLAG meaning
419 #define CodecHal_PictureIsTopField(Pic) (((Pic).PicFlags & PICTURE_TOP_FIELD) != 0)
420 #define CodecHal_PictureIsBottomField(Pic) (((Pic).PicFlags & PICTURE_BOTTOM_FIELD) != 0)
421 #define CodecHal_PictureIsField(pic) \
422 ((CodecHal_PictureIsTopField((pic)) || CodecHal_PictureIsBottomField((pic))) != 0)
423 #define CodecHal_PictureIsFrame(Pic) (((Pic).PicFlags & PICTURE_FRAME) != 0)
424 #define CodecHal_PictureIsInterlacedFrame(Pic) (((Pic).PicFlags & PICTURE_INTERLACED_FRAME) != 0)
425 #define CodecHal_PictureIsLongTermRef(Pic) (((Pic).PicFlags & PICTURE_LONG_TERM_REFERENCE) != 0)
426 #define CodecHal_PictureIsShortTermRef(Pic) (((Pic).PicFlags & PICTURE_SHORT_TERM_REFERENCE) != 0)
427 #define CodecHal_PictureIsInvalid(Pic) (((Pic).PicFlags & PICTURE_INVALID) != 0)
428
429 #define CodecHal_GetFrameFieldHeightInMb(pic, heightInMb, adjustedHeightInMb) \
430 { \
431 if(CodecHal_PictureIsField((pic))) \
432 { \
433 adjustedHeightInMb = ((heightInMb) + 1) >> 1; \
434 } \
435 else \
436 { \
437 adjustedHeightInMb = (heightInMb); \
438 } \
439 }
440
441 #define CodecHalIsDecode(codecFunction) \
442 (codecFunction == CODECHAL_FUNCTION_DECODE || \
443 codecFunction == CODECHAL_FUNCTION_CENC_DECODE)
444
445 #define CodecHalIsDecodeModeVLD(mode) \
446 ((mode == CODECHAL_DECODE_MODE_MPEG2VLD) || \
447 (mode == CODECHAL_DECODE_MODE_VC1VLD) || \
448 (mode == CODECHAL_DECODE_MODE_AVCVLD) || \
449 (mode == CODECHAL_DECODE_MODE_JPEG) || \
450 (mode == CODECHAL_DECODE_MODE_VP8VLD) || \
451 (mode == CODECHAL_DECODE_MODE_HEVCVLD) || \
452 (mode == CODECHAL_DECODE_MODE_VP9VLD))
453
454 #define CodecHalIsDecodeModeIT(mode) \
455 ((mode == CODECHAL_DECODE_MODE_MPEG2IDCT) || \
456 (mode == CODECHAL_DECODE_MODE_VC1IT))
457
458 #define CodecHal_CombinePictureFlags(originalPic, newPic) \
459 ((CODEC_PICTURE_FLAG)((((uint32_t)(originalPic).PicFlags) & 0xF) | ((uint32_t)(newPic).PicFlags)))
460
461 #define CodecHalIsEnableFieldScaling(codecFunction, standard, hint) \
462 ((codecFunction == CODECHAL_FUNCTION_DECODE) && \
463 (standard == CODECHAL_AVC) && \
464 (hint == true))
465
466 #define CodecHalDecodeMapGpuNodeToGpuContex(gpuNode, gpuCtxt, wactx)\
467 do \
468 { \
469 switch (gpuNode) \
470 { \
471 case MOS_GPU_NODE_VIDEO: \
472 gpuCtxt = wactx ? MOS_GPU_CONTEXT_VIDEO2 : MOS_GPU_CONTEXT_VIDEO; \
473 break; \
474 case MOS_GPU_NODE_VIDEO2: \
475 gpuCtxt = wactx ? MOS_GPU_CONTEXT_VDBOX2_VIDEO2 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;\
476 break; \
477 default: \
478 gpuCtxt = wactx ? MOS_GPU_CONTEXT_VIDEO2 : MOS_GPU_CONTEXT_VIDEO; \
479 CODECHAL_DECODE_ASSERTMESSAGE("invalid GPU NODE value."); \
480 break; \
481 } \
482 }while (0)
483
484 #define CodecHalDecode1stHcpDecPhaseInSinglePipeMode(hcpDecPhase, shortFormat)\
485 ((hcpDecPhase == CodechalDecode::CodechalHcpDecodePhaseLegacyS2L && shortFormat) || \
486 (hcpDecPhase == CodechalDecode::CodechalHcpDecodePhaseLegacyLong && !shortFormat))
487
488 // ---------------------------
489 // Functions
490 // ---------------------------
GetReciprocalScalingValue(uint8_t scaleValue)491 static __inline uint16_t GetReciprocalScalingValue(uint8_t scaleValue)
492 {
493 uint16_t reciprocalScaleValue;
494 if (scaleValue < 2)
495 {
496 reciprocalScaleValue = 0xffff;
497 }
498 else
499 {
500 reciprocalScaleValue = (4096 * 16)/scaleValue;
501 }
502
503 return reciprocalScaleValue;
504 }
505
506 // this function covert the input value v to A|B format so v~=B*pow(2, A);
Map44LutValue(uint32_t v,uint8_t max)507 static __inline uint8_t Map44LutValue(uint32_t v, uint8_t max)
508 {
509 uint32_t maxCost;
510 int D;
511 uint8_t ret;
512
513 if (v == 0)
514 {
515 return 0;
516 }
517
518 maxCost = ((max & 15) << (max >> 4));
519 if (v >= maxCost)
520 {
521 return max;
522 }
523
524 D = (int)(log((double)v) / log(2.)) - 3;
525 if (D < 0)
526 {
527 D = 0;
528 }
529
530 ret = (uint8_t)((D << 4) + (int)((v + (D == 0 ? 0 : (1 << (D - 1)))) >> D));
531 ret = (ret & 0xf) == 0 ? (ret | 8) : ret;
532
533 return ret;
534 }
535
GetU62ModeCost(double mcost)536 static __inline uint8_t GetU62ModeCost(double mcost)
537 {
538 return (uint8_t)(mcost * 4 + 0.5);
539 }
540
GetU71ModeCost(double mcost)541 static __inline uint8_t GetU71ModeCost(double mcost)
542 {
543 return (uint8_t)(mcost * 2 + 0.5);
544 }
545
GetU44ModeCost(double mcost)546 static __inline uint8_t GetU44ModeCost(double mcost)
547 {
548 return (uint8_t)(mcost * 16 + 0.5);
549 }
550
LimNumBits(uint8_t cost,int32_t numBits)551 static __inline uint8_t LimNumBits(uint8_t cost, int32_t numBits)
552 {
553 int32_t startBit = -1;
554
555 for (int i = 7; i >= numBits; i--)
556 {
557 if ((cost >> i) != 0)
558 {
559 startBit = i;
560 }
561 }
562
563 if (startBit >= 0)
564 {
565 cost = ((cost >> (startBit - numBits + 1)) << (startBit - numBits + 1));
566 }
567
568 return cost;
569 }
570
CodecHal_GetStandardFromMode(uint32_t mode)571 static __inline uint32_t CodecHal_GetStandardFromMode(uint32_t mode)
572 {
573 uint32_t standard = CODECHAL_UNDEFINED;
574
575 switch (mode)
576 {
577 case CODECHAL_DECODE_MODE_MPEG2IDCT:
578 case CODECHAL_DECODE_MODE_MPEG2VLD:
579 case CODECHAL_ENCODE_MODE_MPEG2:
580 standard = CODECHAL_MPEG2;
581 break;
582 case CODECHAL_DECODE_MODE_VC1IT:
583 case CODECHAL_DECODE_MODE_VC1VLD:
584 standard = CODECHAL_VC1;
585 break;
586 case CODECHAL_DECODE_MODE_AVCVLD:
587 case CODECHAL_ENCODE_MODE_AVC:
588 standard = CODECHAL_AVC;
589 break;
590 case CODECHAL_DECODE_MODE_JPEG:
591 case CODECHAL_ENCODE_MODE_JPEG:
592 standard = CODECHAL_JPEG;
593 break;
594 case CODECHAL_DECODE_MODE_VP8VLD:
595 case CODECHAL_ENCODE_MODE_VP8:
596 standard = CODECHAL_VP8;
597 break;
598 case CODECHAL_DECODE_MODE_HEVCVLD:
599 case CODECHAL_ENCODE_MODE_HEVC:
600 standard = CODECHAL_HEVC;
601 break;
602 case CODECHAL_ENCODE_MODE_VP9:
603 case CODECHAL_DECODE_MODE_VP9VLD:
604 standard = CODECHAL_VP9;
605 break;
606 case CODECHAL_DECODE_MODE_CENC:
607 standard = CODECHAL_CENC;
608 break;
609 case CODECHAL_ENCODE_RESERVED_0:
610 standard = CODECHAL_RESERVED0;
611 break;
612 default:
613 standard = CODECHAL_UNDEFINED;
614 break;
615 }
616
617 return standard;
618 }
619
CodecHal_Clip3(int x,int y,int z)620 static __inline int32_t CodecHal_Clip3(int x, int y, int z)
621 {
622 int32_t ret = 0;
623
624 if (z < x)
625 {
626 ret = x;
627 }
628 else if (z > y)
629 {
630 ret = y;
631 }
632 else
633 {
634 ret = z;
635 }
636
637 return ret;
638 }
639
CeilLog2(uint32_t value)640 static __inline uint32_t CeilLog2(uint32_t value)
641 {
642 uint32_t res = 0;
643
644 while (value > (uint32_t)(1 << res)) res++;
645
646 return res;
647 }
648
649 #endif // __CODEC_DEF_COMMON_H__
650