1 /* 2 * Copyright (c) 2021 Rockchip Electronics Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef __VPU_API_H__ 17 #define __VPU_API_H__ 18 19 #include "rk_type.h" 20 #include "mpp_err.h" 21 22 /** 23 * @brief rockchip media process interface 24 */ 25 26 #define VPU_API_NOPTS_VALUE (0x8000000000000000LL) 27 28 /* 29 * bit definition of ColorType in structure VPU_FRAME 30 */ 31 #define VPU_OUTPUT_FORMAT_TYPE_MASK (0x0000ffff) 32 #define VPU_OUTPUT_FORMAT_ARGB8888 (0x00000000) 33 #define VPU_OUTPUT_FORMAT_ABGR8888 (0x00000001) 34 #define VPU_OUTPUT_FORMAT_RGB888 (0x00000002) 35 #define VPU_OUTPUT_FORMAT_RGB565 (0x00000003) 36 #define VPU_OUTPUT_FORMAT_RGB555 (0x00000004) 37 #define VPU_OUTPUT_FORMAT_YUV420_SEMIPLANAR (0x00000005) 38 #define VPU_OUTPUT_FORMAT_YUV420_PLANAR (0x00000006) 39 #define VPU_OUTPUT_FORMAT_YUV422 (0x00000007) 40 #define VPU_OUTPUT_FORMAT_YUV444 (0x00000008) 41 #define VPU_OUTPUT_FORMAT_YCH420 (0x00000009) 42 #define VPU_OUTPUT_FORMAT_BIT_MASK (0x000f0000) 43 #define VPU_OUTPUT_FORMAT_BIT_8 (0x00000000) 44 #define VPU_OUTPUT_FORMAT_BIT_10 (0x00010000) 45 #define VPU_OUTPUT_FORMAT_BIT_12 (0x00020000) 46 #define VPU_OUTPUT_FORMAT_BIT_14 (0x00030000) 47 #define VPU_OUTPUT_FORMAT_BIT_16 (0x00040000) 48 #define VPU_OUTPUT_FORMAT_COLORSPACE_MASK (0x00f00000) 49 #define VPU_OUTPUT_FORMAT_COLORSPACE_BT709 (0x00100000) 50 #define VPU_OUTPUT_FORMAT_COLORSPACE_BT2020 (0x00200000) 51 #define VPU_OUTPUT_FORMAT_DYNCRANGE_MASK (0x0f000000) 52 #define VPU_OUTPUT_FORMAT_DYNCRANGE_SDR (0x00000000) 53 #define VPU_OUTPUT_FORMAT_DYNCRANGE_HDR10 (0x01000000) 54 #define VPU_OUTPUT_FORMAT_DYNCRANGE_HDR_HLG (0x02000000) 55 #define VPU_OUTPUT_FORMAT_DYNCRANGE_HDR_DOLBY (0x03000000) 56 57 /** 58 * @brief input picture type 59 */ 60 typedef enum { 61 ENC_INPUT_YUV420_PLANAR = 0, /**< YYYY... UUUU... VVVV */ 62 ENC_INPUT_YUV420_SEMIPLANAR = 1, /**< YYYY... UVUVUV... */ 63 ENC_INPUT_YUV422_INTERLEAVED_YUYV = 2, /**< YUYVYUYV... */ 64 ENC_INPUT_YUV422_INTERLEAVED_UYVY = 3, /**< UYVYUYVY... */ 65 ENC_INPUT_RGB565 = 4, /**< 16-bit RGB */ 66 ENC_INPUT_BGR565 = 5, /**< 16-bit RGB */ 67 ENC_INPUT_RGB555 = 6, /**< 15-bit RGB */ 68 ENC_INPUT_BGR555 = 7, /**< 15-bit RGB */ 69 ENC_INPUT_RGB444 = 8, /**< 12-bit RGB */ 70 ENC_INPUT_BGR444 = 9, /**< 12-bit RGB */ 71 ENC_INPUT_RGB888 = 10, /**< 24-bit RGB */ 72 ENC_INPUT_BGR888 = 11, /**< 24-bit RGB */ 73 ENC_INPUT_RGB101010 = 12, /**< 30-bit RGB */ 74 ENC_INPUT_BGR101010 = 13 /**< 30-bit RGB */ 75 } EncInputPictureType; 76 77 typedef enum VPU_API_CMD { 78 VPU_API_ENC_SETCFG, 79 VPU_API_ENC_GETCFG, 80 VPU_API_ENC_SETFORMAT, 81 VPU_API_ENC_SETIDRFRAME, 82 83 VPU_API_ENABLE_DEINTERLACE, 84 VPU_API_SET_VPUMEM_CONTEXT, 85 VPU_API_USE_PRESENT_TIME_ORDER, 86 VPU_API_SET_DEFAULT_WIDTH_HEIGH, 87 VPU_API_SET_INFO_CHANGE, 88 VPU_API_USE_FAST_MODE, 89 VPU_API_DEC_GET_STREAM_COUNT, 90 VPU_API_GET_VPUMEM_USED_COUNT, 91 VPU_API_GET_FRAME_INFO, 92 VPU_API_SET_OUTPUT_BLOCK, 93 VPU_API_GET_EOS_STATUS, 94 VPU_API_SET_OUTPUT_MODE, 95 96 VPU_API_DEC_GET_DPB_SIZE = 0X100, 97 98 /* get sps/pps header */ 99 VPU_API_GET_EXTRA_INFO = 0x200, 100 101 VPU_API_SET_IMMEDIATE_OUT = 0x1000, 102 VPU_API_SET_PARSER_SPLIT_MODE, /* NOTE: should control before init */ 103 104 VPU_API_ENC_VEPU22_START = 0x2000, 105 VPU_API_ENC_SET_VEPU22_CFG, 106 VPU_API_ENC_GET_VEPU22_CFG, 107 VPU_API_ENC_SET_VEPU22_CTU_QP, 108 VPU_API_ENC_SET_VEPU22_ROI, 109 110 /* mlvec dynamic configure */ 111 VPU_API_ENC_MLVEC_CFG = 0x4000, 112 VPU_API_ENC_SET_MAX_TID, 113 VPU_API_ENC_SET_MARK_LTR, 114 VPU_API_ENC_SET_USE_LTR, 115 VPU_API_ENC_SET_FRAME_QP, 116 VPU_API_ENC_SET_BASE_LAYER_PID, 117 } VPU_API_CMD; 118 119 typedef struct { 120 RK_U32 TimeLow; 121 RK_U32 TimeHigh; 122 } TIME_STAMP; 123 124 typedef struct { 125 RK_U32 CodecType; 126 RK_U32 ImgWidth; 127 RK_U32 ImgHeight; 128 RK_U32 ImgHorStride; 129 RK_U32 ImgVerStride; 130 RK_U32 BufSize; 131 } VPU_GENERIC; 132 133 typedef struct VPUMem { 134 RK_U32 phy_addr; 135 RK_U32 *vir_addr; 136 RK_U32 size; 137 RK_U32 *offset; 138 } VPUMemLinear_t; 139 140 typedef struct tVPU_FRAME { 141 RK_U32 FrameBusAddr[2]; // 0: Y address; 1: UV address; 142 RK_U32 FrameWidth; // buffer horizontal stride 143 RK_U32 FrameHeight; // buffer vertical stride 144 RK_U32 OutputWidth; // deprecated 145 RK_U32 OutputHeight; // deprecated 146 RK_U32 DisplayWidth; // valid width for display 147 RK_U32 DisplayHeight; // valid height for display 148 RK_U32 CodingType; 149 RK_U32 FrameType; // frame; top_field_first; bot_field_first 150 RK_U32 ColorType; 151 RK_U32 DecodeFrmNum; 152 TIME_STAMP ShowTime; 153 RK_U32 ErrorInfo; // error information 154 RK_U32 employ_cnt; 155 VPUMemLinear_t vpumem; 156 struct tVPU_FRAME *next_frame; 157 union { 158 struct { 159 RK_U32 Res0[2]; 160 struct { 161 RK_U32 ColorPrimaries : 8; 162 RK_U32 ColorTransfer : 8; 163 RK_U32 ColorCoeffs : 8; 164 RK_U32 ColorRange : 1; 165 RK_U32 Res1 : 7; 166 }; 167 168 RK_U32 Res2; 169 }; 170 171 RK_U32 Res[4]; 172 }; 173 } VPU_FRAME; 174 175 typedef struct VideoPacket { 176 RK_S64 pts; /* with unit of us */ 177 RK_S64 dts; /* with unit of us */ 178 RK_U8 *data; 179 RK_S32 size; 180 RK_U32 capability; 181 RK_U32 nFlags; 182 } VideoPacket_t; 183 184 typedef struct DecoderOut { 185 RK_U8 *data; 186 RK_U32 size; 187 RK_S64 timeUs; 188 RK_S32 nFlags; 189 } DecoderOut_t; 190 191 typedef struct ParserOut { 192 RK_U8 *data; 193 RK_U32 size; 194 RK_S64 timeUs; 195 RK_U32 nFlags; 196 RK_U32 width; 197 RK_U32 height; 198 } ParserOut_t; 199 200 typedef struct EncInputStream { 201 RK_U8 *buf; 202 RK_S32 size; 203 RK_U32 bufPhyAddr; 204 RK_S64 timeUs; 205 RK_U32 nFlags; 206 } EncInputStream_t; 207 208 typedef struct EncoderOut { 209 RK_U8 *data; 210 RK_S32 size; 211 RK_S64 timeUs; 212 RK_S32 keyFrame; 213 } EncoderOut_t; 214 215 /* 216 * @brief Enumeration used to define the possible video compression codings. 217 * @note This essentially refers to file extensions. If the coding is 218 * being used to specify the ENCODE type, then additional work 219 * must be done to configure the exact flavor of the compression 220 * to be used. For decode cases where the user application can 221 * not differentiate between MPEG-4 and H.264 bit streams, it is 222 * up to the codec to handle this. 223 * 224 * sync with the omx_video.h 225 */ 226 typedef enum OMX_RK_VIDEO_CODINGTYPE { 227 OMX_RK_VIDEO_CodingUnused, /**< Value when coding is N/A */ 228 OMX_RK_VIDEO_CodingAutoDetect, /**< Autodetection of coding type */ 229 OMX_RK_VIDEO_CodingMPEG2, /**< AKA: H.262 */ 230 OMX_RK_VIDEO_CodingH263, /**< H.263 */ 231 OMX_RK_VIDEO_CodingMPEG4, /**< MPEG-4 */ 232 OMX_RK_VIDEO_CodingWMV, /**< Windows Media Video (WMV1,WMV2,WMV3)*/ 233 OMX_RK_VIDEO_CodingRV, /**< all versions of Real Video */ 234 OMX_RK_VIDEO_CodingAVC, /**< H.264/AVC */ 235 OMX_RK_VIDEO_CodingMJPEG, /**< Motion JPEG */ 236 OMX_RK_VIDEO_CodingVP8, /**< VP8 */ 237 OMX_RK_VIDEO_CodingVP9, /**< VP9 */ 238 OMX_RK_VIDEO_CodingVC1 = 0x01000000, /**< Windows Media Video (WMV1,WMV2,WMV3)*/ 239 OMX_RK_VIDEO_CodingFLV1, /**< Sorenson H.263 */ 240 OMX_RK_VIDEO_CodingDIVX3, /**< DIVX3 */ 241 OMX_RK_VIDEO_CodingVP6, 242 OMX_RK_VIDEO_CodingHEVC, /**< H.265/HEVC */ 243 OMX_RK_VIDEO_CodingAVS, /**< AVS+ */ 244 OMX_RK_VIDEO_CodingKhronosExtensions = 0x6F000000, 245 OMX_RK_VIDEO_CodingVendorStartUnused = 0x7F000000, 246 OMX_RK_VIDEO_CodingMax = 0x7FFFFFFF 247 } OMX_RK_VIDEO_CODINGTYPE; 248 249 typedef enum CODEC_TYPE { 250 CODEC_NONE, 251 CODEC_DECODER, 252 CODEC_ENCODER, 253 CODEC_BUTT, 254 } CODEC_TYPE; 255 256 typedef enum VPU_API_ERR { 257 VPU_API_OK = 0, 258 VPU_API_ERR_UNKNOW = -1, 259 VPU_API_ERR_BASE = -1000, 260 VPU_API_ERR_LIST_STREAM = VPU_API_ERR_BASE - 1, 261 VPU_API_ERR_INIT = VPU_API_ERR_BASE - 2, 262 VPU_API_ERR_VPU_CODEC_INIT = VPU_API_ERR_BASE - 3, 263 VPU_API_ERR_STREAM = VPU_API_ERR_BASE - 4, 264 VPU_API_ERR_FATAL_THREAD = VPU_API_ERR_BASE - 5, 265 VPU_API_EOS_STREAM_REACHED = VPU_API_ERR_BASE - 11, 266 267 VPU_API_ERR_BUTT, 268 } VPU_API_ERR; 269 270 typedef enum VPU_FRAME_ERR { 271 VPU_FRAME_ERR_UNKNOW = 0x0001, 272 VPU_FRAME_ERR_UNSUPPORT = 0x0002, 273 274 } VPU_FRAME_ERR; 275 276 typedef struct EncParameter { 277 RK_S32 width; 278 RK_S32 height; 279 RK_S32 rc_mode; /* 0 - CQP mode; 1 - CBR mode; 2 - FIXQP mode */ 280 RK_S32 bitRate; /* target bitrate */ 281 RK_S32 framerate; 282 RK_S32 qp; 283 RK_S32 enableCabac; 284 RK_S32 cabacInitIdc; 285 RK_S32 format; 286 RK_S32 intraPicRate; 287 RK_S32 framerateout; 288 RK_S32 profileIdc; 289 RK_S32 levelIdc; 290 RK_S32 reserved[3]; 291 } EncParameter_t; 292 293 typedef struct EXtraCfg { 294 RK_S32 vc1extra_size; 295 RK_S32 vp6codeid; 296 RK_S32 tsformat; 297 RK_U32 ori_vpu; /* use origin vpu framework */ 298 /* below used in decode */ 299 RK_U32 mpp_mode; /* use mpp framework */ 300 RK_U32 bit_depth; /* 8 or 10 bit */ 301 RK_U32 yuv_format; /* 0:420 1:422 2:444 */ 302 RK_U32 reserved[16]; 303 } EXtraCfg_t; 304 305 /** 306 * @brief vpu function interface 307 */ 308 typedef struct VpuCodecContext { 309 void* vpuApiObj; 310 311 CODEC_TYPE codecType; 312 OMX_RK_VIDEO_CODINGTYPE videoCoding; 313 314 RK_U32 width; 315 RK_U32 height; 316 void *extradata; 317 RK_S32 extradata_size; 318 319 RK_U8 enableparsing; 320 321 RK_S32 no_thread; 322 EXtraCfg_t extra_cfg; 323 324 void* private_data; 325 326 /* 327 ** 1: error state(not working) 0: working 328 */ 329 RK_S32 decoder_err; 330 331 /** 332 * Allocate and initialize an VpuCodecContext. 333 * 334 * @param ctx The context of vpu api, allocated in this function. 335 * @param extraData The extra data of codec, some codecs need / can 336 * use extradata like Huffman tables, also live VC1 codec can 337 * use extradata to initialize itself. 338 * @param extra_size The size of extra data. 339 * 340 * @return 0 for init success, others for failure. 341 * @note check whether ctx has been allocated success after you do init. 342 */ 343 RK_S32 (*init)(struct VpuCodecContext *ctx, RK_U8 *extraData, RK_U32 extra_size); 344 /** 345 * @brief both send video stream packet to decoder and get video frame from 346 * decoder at the same time 347 * @param ctx The context of vpu codec 348 * @param pkt[in] Stream to be decoded 349 * @param aDecOut[out] Decoding frame 350 * @return 0 for decode success, others for failure. 351 */ 352 RK_S32 (*decode)(struct VpuCodecContext *ctx, VideoPacket_t *pkt, DecoderOut_t *aDecOut); 353 /** 354 * @brief both send video frame to encoder and get encoded video stream from 355 * encoder at the same time. 356 * @param ctx The context of vpu codec 357 * @param aEncInStrm[in] Frame to be encoded 358 * @param aEncOut[out] Encoding stream 359 * @return 0 for encode success, others for failure. 360 */ 361 RK_S32 (*encode)(struct VpuCodecContext *ctx, EncInputStream_t *aEncInStrm, EncoderOut_t *aEncOut); 362 /** 363 * @brief flush codec while do fast forward playing. 364 * @param ctx The context of vpu codec 365 * @return 0 for flush success, others for failure. 366 */ 367 RK_S32 (*flush)(struct VpuCodecContext *ctx); 368 RK_S32 (*control)(struct VpuCodecContext *ctx, VPU_API_CMD cmdType, void* param); 369 /** 370 * @brief send video stream packet to decoder only, async interface 371 * @param ctx The context of vpu codec 372 * @param pkt Stream to be decoded 373 * @return 0 for success, others for failure. 374 */ 375 RK_S32 (*decode_sendstream)(struct VpuCodecContext *ctx, VideoPacket_t *pkt); 376 /** 377 * @brief get video frame from decoder only, async interface 378 * @param ctx The context of vpu codec 379 * @param aDecOut Decoding frame 380 * @return 0 for success, others for failure. 381 */ 382 RK_S32 (*decode_getframe)(struct VpuCodecContext *ctx, DecoderOut_t *aDecOut); 383 /** 384 * @brief send video frame to encoder only, async interface 385 * @param ctx The context of vpu codec 386 * @param aEncInStrm Frame to be encoded 387 * @return 0 for success, others for failure. 388 */ 389 RK_S32 (*encoder_sendframe)(struct VpuCodecContext *ctx, EncInputStream_t *aEncInStrm); 390 /** 391 * @brief get encoded video packet from encoder only, async interface 392 * @param ctx The context of vpu codec 393 * @param aEncOut Encoding stream 394 * @return 0 for success, others for failure. 395 */ 396 RK_S32 (*encoder_getstream)(struct VpuCodecContext *ctx, EncoderOut_t *aEncOut); 397 } VpuCodecContext_t; 398 399 /* allocated vpu codec context */ 400 #ifdef __cplusplus 401 extern "C" 402 { 403 #endif 404 405 /** 406 * @brief open context of vpu 407 * @param ctx pointer of vpu codec context 408 */ 409 RK_S32 vpu_open_context(struct VpuCodecContext **ctx); 410 /** 411 * @brief close context of vpu 412 * @param ctx pointer of vpu codec context 413 */ 414 RK_S32 vpu_close_context(struct VpuCodecContext **ctx); 415 416 #ifdef __cplusplus 417 } 418 #endif 419 420 /* 421 * vpu_mem api 422 */ 423 #define vpu_display_mem_pool_FIELDS \ 424 RK_S32 (*commit_hdl)(vpu_display_mem_pool *p, RK_S32 hdl, RK_S32 size); \ 425 void* (*get_free)(vpu_display_mem_pool *p); \ 426 RK_S32 (*inc_used)(vpu_display_mem_pool *p, void *hdl); \ 427 RK_S32 (*put_used)(vpu_display_mem_pool *p, void *hdl); \ 428 RK_S32 (*reset)(vpu_display_mem_pool *p); \ 429 RK_S32 (*get_unused_num)(vpu_display_mem_pool *p); \ 430 RK_S32 buff_size; \ 431 float version; \ 432 RK_S32 res[18]; 433 434 typedef struct vpu_display_mem_pool vpu_display_mem_pool; 435 436 struct vpu_display_mem_pool { 437 vpu_display_mem_pool_FIELDS 438 }; 439 440 #ifdef __cplusplus 441 extern "C" 442 { 443 #endif 444 445 /* 446 * vpu memory handle interface 447 */ 448 RK_S32 VPUMemJudgeIommu(void); 449 RK_S32 VPUMallocLinear(VPUMemLinear_t *p, RK_U32 size); 450 RK_S32 VPUFreeLinear(VPUMemLinear_t *p); 451 RK_S32 VPUMemDuplicate(VPUMemLinear_t *dst, VPUMemLinear_t *src); 452 RK_S32 VPUMemLink(VPUMemLinear_t *p); 453 RK_S32 VPUMemFlush(VPUMemLinear_t *p); 454 RK_S32 VPUMemClean(VPUMemLinear_t *p); 455 RK_S32 VPUMemInvalidate(VPUMemLinear_t *p); 456 RK_S32 VPUMemGetFD(VPUMemLinear_t *p); 457 RK_S32 VPUMallocLinearFromRender(VPUMemLinear_t *p, RK_U32 size, void *ctx); 458 459 /* 460 * vpu memory allocator and manager interface 461 */ 462 vpu_display_mem_pool* open_vpu_memory_pool(void); 463 void close_vpu_memory_pool(vpu_display_mem_pool *p); 464 int create_vpu_memory_pool_allocator(vpu_display_mem_pool **ipool, int num, int size); 465 void release_vpu_memory_pool_allocator(vpu_display_mem_pool *ipool); 466 467 #ifdef __cplusplus 468 } 469 #endif 470 471 #endif 472