projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


83adc1ee6b26450d5c69f9db0a6ceec1ffb429f6
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / vcodec / venc_drv_if_public.h
1 /**
2 * @file
3 * venc_drv_if_public.h
4 *
5 * @par Project:
6 * Video
7 *
8 * @par Description:
9 * Video Encoder Driver Interface for external use
10 *
11 * @par Author:
12 * Jackal Chen (mtk02532)
13 *
14 * @par $Revision: #1 $
15 * @par $Modtime:$
16 * @par $Log:$
17 *
18 */
19
20 #ifndef _VENC_DRV_IF_PUBLIC_H_
21 #define _VENC_DRV_IF_PUBLIC_H_
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 #include "val_types_public.h"
28
29
30 /**
31 * @par Enumeration
32 * VENC_DRV_QUERY_TYPE_T
33 * @par Description
34 * This is the item used for query driver
35 */
36 typedef enum __VENC_DRV_QUERY_TYPE_T
37 {
38 VENC_DRV_QUERY_TYPE_NONE, ///< Default value (not used)
39 VENC_DRV_QUERY_TYPE_VIDEO_FORMAT, ///< Query the driver capability
40 VENC_DRV_QUERY_TYPE_VIDEO_PROPERTY, ///< Query the video property
41 VENC_DRV_QUERY_TYPE_VIDEO_PROPERTY_LIST, ///< Query the video property list
42 VENC_DRV_QUERY_TYPE_PROPERTY, ///< Get the driver property
43 VENC_DRV_QUERY_TYPE_MCI_SUPPORTED, ///< Query if the codec support MCI
44 VENC_DRV_QUERY_TYPE_CHIP_NAME, ///< Query chip name
45 VENC_DRV_QUERY_TYPE_INPUT_BUF_LIMIT, ///< Query input buffer stride and sliceheight
46 VENC_DRV_QUERY_TYPE_NORMAL_PRIO, ///< Query if recorder scenario adjust to normal priority, for 6571.
47 VENC_DRV_QUERY_TYPE_VIDEO_CAMCORDER_CAP, ///< Query spec. for MediaProfile
48 VENC_DRV_QUERY_TYPE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_QUERY_TYPE_T value
49 }
50 VENC_DRV_QUERY_TYPE_T;
51
52
53 /**
54 * @par Enumeration
55 * VENC_DRV_YUV_FORMAT_T
56 * @par Description
57 * This is the item used for input YUV buffer format
58 */
59 typedef enum __VENC_DRV_YUV_FORMAT_T
60 {
61 VENC_DRV_YUV_FORMAT_NONE, ///< Default value (not used)
62 VENC_DRV_YUV_FORMAT_GRAY, ///< GRAY YUV format
63 VENC_DRV_YUV_FORMAT_422, ///< 422 YUV format
64 VENC_DRV_YUV_FORMAT_420, ///< 420 YUV format
65 VENC_DRV_YUV_FORMAT_411, ///< 411 YUV format
66 VENC_DRV_YUV_FORMAT_YV12, ///< Android YV12 (16/16/16) YUV format
67 VENC_DRV_YUV_FORMAT_NV12, ///< NV12 YUV format
68 VENC_DRV_YUV_FORMAT_NV21, ///< NV21 YUV format
69 VENC_DRV_YUV_FORMAT_BLK16X32, ///< Block 16x32 YUV format
70 VENC_DRV_YUV_FORMAT_BLK64X32, ///< Block 64x32 YUV format
71 VENC_DRV_YUV_FORMAT_YV12_1688, ///< YV12 YUV format
72 VENC_DRV_YUV_FORMAT_MAX = 0xFFFFFFFF ///< Max VENC_DRV_YUV_FORMAT_T value
73 } VENC_DRV_YUV_FORMAT_T;
74
75
76 /**
77 * @par Enumeration
78 * VENC_DRV_VIDEO_FORMAT_T
79 * @par Description
80 * This is the item used for encode video format
81 */
82 typedef enum __VENC_DRV_VIDEO_FORMAT_T
83 {
84 VENC_DRV_VIDEO_FORMAT_NONE, ///< Default value (not used)
85 VENC_DRV_VIDEO_FORMAT_MPEG4, ///< MPEG4 video format
86 VENC_DRV_VIDEO_FORMAT_MPEG4_1080P, ///< MPEG4 video format for 1080p
87 VENC_DRV_VIDEO_FORMAT_MPEG4_SHORT, ///< MPEG4_SHORT (H.263 baseline profile) video format
88 VENC_DRV_VIDEO_FORMAT_H263, ///< H.263 video format
89 VENC_DRV_VIDEO_FORMAT_H264, ///< H.264 video format
90 VENC_DRV_VIDEO_FORMAT_H264_VGA, ///< H.264 video format for VGA
91 VENC_DRV_VIDEO_FORMAT_WMV9, ///< WMV9 video format
92 VENC_DRV_VIDEO_FORMAT_VC1, ///< VC1 video format
93 VENC_DRV_VIDEO_FORMAT_VP8, ///< VP8 video format
94 VENC_DRV_VIDEO_FORMAT_JPEG, ///< JPEG picture format
95 VENC_DRV_VIDEO_FORMAT_HEVC, ///< HEVC video format
96 VENC_DRV_VIDEO_FORMAT_H264SEC, ///<: Secure H.264
97 VENC_DRV_VIDEO_FORMAT_MAX = 0xFFFFFFFF ///< Max VENC_DRV_VIDEO_FORMAT_T value
98 } VENC_DRV_VIDEO_FORMAT_T;
99
100
101 /**
102 * @par Enumeration
103 * VENC_DRV_FRAME_RATE_T
104 * @par Description
105 * This is the item used for encode frame rate
106 */
107 typedef enum __VENC_DRV_FRAME_RATE_T
108 {
109 VENC_DRV_FRAME_RATE_NONE = 0, ///< Default value (not used)
110 VENC_DRV_FRAME_RATE_7_5 = 75, ///< 7.5
111 VENC_DRV_FRAME_RATE_10 = 10, ///< 10
112 VENC_DRV_FRAME_RATE_15 = 15, ///< 15
113 VENC_DRV_FRAME_RATE_20 = 20, ///< 20
114 VENC_DRV_FRAME_RATE_24 = 24, ///< 24
115 VENC_DRV_FRAME_RATE_25 = 25, ///< 25
116 VENC_DRV_FRAME_RATE_29_97 = 2997, ///< 29.97
117 VENC_DRV_FRAME_RATE_30 = 30, ///< 30
118 VENC_DRV_FRAME_RATE_60 = 60, ///< 60
119 VENC_DRV_FRAME_RATE_120 = 120, ///< 120
120 VENC_DRV_FRAME_RATE_180 = 180, ///< 180
121 VENC_DRV_FRAME_RATE_240 = 240, ///< 240
122 VENC_DRV_FRAME_RATE_480 = 480, ///< 480
123 VENC_DRV_FRAME_RATE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_FRAME_RATE_T value
124 } VENC_DRV_FRAME_RATE_T;
125
126
127 /**
128 * @par Enumeration
129 * VENC_DRV_START_OPT_T
130 * @par Description
131 * This is the item used for encode frame type
132 */
133 typedef enum __VENC_DRV_START_OPT_T
134 {
135 VENC_DRV_START_OPT_NONE, ///< Default value (not used)
136 VENC_DRV_START_OPT_ENCODE_SEQUENCE_HEADER, ///< Encode a Sequence header
137 VENC_DRV_START_OPT_ENCODE_SEQUENCE_HEADER_H264_SPS, ///< Encode a Sequence header H264 SPS
138 VENC_DRV_START_OPT_ENCODE_SEQUENCE_HEADER_H264_PPS, ///< Encode a Sequence header H264 PPS
139 VENC_DRV_START_OPT_ENCODE_FRAME, ///< Encode a frame
140 VENC_DRV_START_OPT_ENCODE_KEY_FRAME, ///< Encode a key frame
141 VENC_DRV_START_OPT_ENCODE_FINAL, ///< Final encode (Only use to encode final frame)
142 VENC_DRV_START_OPT_ENCODE_DUMMY_NAL, ///< Encode a dummy NAL for WFD
143 VENC_DRV_START_OPT_MAX = 0xFFFFFFFF ///< Max VENC_DRV_START_OPT_T value
144 } VENC_DRV_START_OPT_T;
145
146
147 /**
148 * @par Enumeration
149 * VENC_DRV_MESSAGE_T
150 * @par Description
151 * This is the item used for encode frame status
152 */
153 typedef enum __VENC_DRV_MESSAGE_T
154 {
155 VENC_DRV_MESSAGE_NONE, ///< Default value (not used)
156 VENC_DRV_MESSAGE_OK, ///< Encode ok
157 VENC_DRV_MESSAGE_ERR, ///< Encode error
158 VENC_DRV_MESSAGE_TIMEOUT, ///< Encode timeout
159 VENC_DRV_MESSAGE_PARTIAL, ///< Encode partial frame (ok means EOF)
160 VENC_DRV_MESSAGE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_MESSAGE_T value
161 } VENC_DRV_MESSAGE_T;
162
163
164 /**
165 * @par Enumeration
166 * VENC_DRV_H264_VIDEO_PROFILE_T
167 * @par Description
168 * This is the item used for h.264 encoder profile capability
169 */
170 typedef enum __VENC_DRV_H264_VIDEO_PROFILE_T
171 {
172 VENC_DRV_H264_VIDEO_PROFILE_UNKNOWN = 0, ///< Default value (not used)
173 VENC_DRV_H264_VIDEO_PROFILE_BASELINE = (1 << 0), ///< Baseline
174 VENC_DRV_H264_VIDEO_PROFILE_CONSTRAINED_BASELINE = (1 << 1), ///< Constrained Baseline
175 VENC_DRV_H264_VIDEO_PROFILE_MAIN = (1 << 2), ///< Main
176 VENC_DRV_H264_VIDEO_PROFILE_EXTENDED = (1 << 3), ///< Extended
177 VENC_DRV_H264_VIDEO_PROFILE_HIGH = (1 << 4), ///< High
178 VENC_DRV_H264_VIDEO_PROFILE_HIGH_10 = (1 << 5), ///< High 10
179 VENC_DRV_H264_VIDEO_PROFILE_HIGH422 = (1 << 6), ///< High 422
180 VENC_DRV_H264_VIDEO_PROFILE_HIGH444 = (1 << 7), ///< High 444
181 VENC_DRV_H264_VIDEO_PROFILE_HIGH_10_INTRA = (1 << 8), ///< High 10 Intra (Amendment 2)
182 VENC_DRV_H264_VIDEO_PROFILE_HIGH422_INTRA = (1 << 9), ///< High 422 Intra (Amendment 2)
183 VENC_DRV_H264_VIDEO_PROFILE_HIGH444_INTRA = (1 << 10), ///< High 444 Intra (Amendment 2)
184 VENC_DRV_H264_VIDEO_PROFILE_CAVLC444_INTRA = (1 << 11), ///< CAVLC 444 Intra (Amendment 2)
185 VENC_DRV_H264_VIDEO_PROFILE_HIGH444_PREDICTIVE = (1 << 12), ///< High 444 Predictive (Amendment 2)
186 VENC_DRV_H264_VIDEO_PROFILE_SCALABLE_BASELINE = (1 << 13), ///< Scalable Baseline (Amendment 3)
187 VENC_DRV_H264_VIDEO_PROFILE_SCALABLE_HIGH = (1 << 14), ///< Scalable High (Amendment 3)
188 VENC_DRV_H264_VIDEO_PROFILE_SCALABLE_HIGH_INTRA = (1 << 15), ///< Scalable High Intra (Amendment 3)
189 VENC_DRV_H264_VIDEO_PROFILE_MULTIVIEW_HIGH = (1 << 16), ///< Multiview High (Corrigendum 1 (2009))
190 VENC_DRV_H264_VIDEO_PROFILE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_H264_VIDEO_PROFILE_T value
191 } VENC_DRV_H264_VIDEO_PROFILE_T;
192
193
194 /**
195 * @par Enumeration
196 * VENC_DRV_HEVC_VIDEO_PROFILE_T
197 * @par Description
198 * This is the item used for hevc encoder profile capability
199 */
200 typedef enum __VENC_DRV_HEVC_VIDEO_PROFILE_T
201 {
202 VENC_DRV_HEVC_VIDEO_PROFILE_UNKNOWN = 0, ///< Default value (not used)
203 VENC_DRV_HEVC_VIDEO_PROFILE_BASELINE = (1 << 0), ///< Baseline
204 VENC_DRV_HEVC_VIDEO_PROFILE_CONSTRAINED_BASELINE = (1 << 1), ///< Constrained Baseline
205 VENC_DRV_HEVC_VIDEO_PROFILE_MAIN = (1 << 2), ///< Main
206 VENC_DRV_HEVC_VIDEO_PROFILE_EXTENDED = (1 << 3), ///< Extended
207 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH = (1 << 4), ///< High
208 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH_10 = (1 << 5), ///< High 10
209 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH422 = (1 << 6), ///< High 422
210 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH444 = (1 << 7), ///< High 444
211 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH_10_INTRA = (1 << 8), ///< High 10 Intra (Amendment 2)
212 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH422_INTRA = (1 << 9), ///< High 422 Intra (Amendment 2)
213 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH444_INTRA = (1 << 10), ///< High 444 Intra (Amendment 2)
214 VENC_DRV_HEVC_VIDEO_PROFILE_CAVLC444_INTRA = (1 << 11), ///< CAVLC 444 Intra (Amendment 2)
215 VENC_DRV_HEVC_VIDEO_PROFILE_HIGH444_PREDICTIVE = (1 << 12), ///< High 444 Predictive (Amendment 2)
216 VENC_DRV_HEVC_VIDEO_PROFILE_SCALABLE_BASELINE = (1 << 13), ///< Scalable Baseline (Amendment 3)
217 VENC_DRV_HEVC_VIDEO_PROFILE_SCALABLE_HIGH = (1 << 14), ///< Scalable High (Amendment 3)
218 VENC_DRV_HEVC_VIDEO_PROFILE_SCALABLE_HIGH_INTRA = (1 << 15), ///< Scalable High Intra (Amendment 3)
219 VENC_DRV_HEVC_VIDEO_PROFILE_MULTIVIEW_HIGH = (1 << 16), ///< Multiview High (Corrigendum 1 (2009))
220 VENC_DRV_HEVC_VIDEO_PROFILE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_HEVC_VIDEO_PROFILE_T value
221 } VENC_DRV_HEVC_VIDEO_PROFILE_T;
222
223
224 /**
225 * @par Enumeration
226 * VENC_DRV_MPEG_VIDEO_PROFILE_T
227 * @par Description
228 * This is the item used for h.263, mpeg2, mpeg4 encoder profile capability
229 */
230 typedef enum __VENC_DRV_MPEG_VIDEO_PROFILE_T
231 {
232 VENC_DRV_MPEG_VIDEO_PROFILE_UNKNOWN = 0, ///< Default value (not used)
233 VENC_DRV_MPEG_VIDEO_PROFILE_H263_0 = (1 << 0), ///< H.263 0
234 VENC_DRV_MPEG_VIDEO_PROFILE_H263_1 = (1 << 1), ///< H.263 1
235 VENC_DRV_MPEG_VIDEO_PROFILE_H263_2 = (1 << 2), ///< H.263 2
236 VENC_DRV_MPEG_VIDEO_PROFILE_H263_3 = (1 << 3), ///< H.263 3
237 VENC_DRV_MPEG_VIDEO_PROFILE_H263_4 = (1 << 4), ///< H.263 4
238 VENC_DRV_MPEG_VIDEO_PROFILE_H263_5 = (1 << 5), ///< H.263 5
239 VENC_DRV_MPEG_VIDEO_PROFILE_H263_6 = (1 << 6), ///< H.263 6
240 VENC_DRV_MPEG_VIDEO_PROFILE_H263_7 = (1 << 7), ///< H.263 7
241 VENC_DRV_MPEG_VIDEO_PROFILE_H263_8 = (1 << 8), ///< H.263 8
242 VENC_DRV_MPEG_VIDEO_PROFILE_MPEG2_SIMPLE = (1 << 9), ///< MPEG2 Simple
243 VENC_DRV_MPEG_VIDEO_PROFILE_MPEG2_MAIN = (1 << 10), ///< MPEG2 Main
244 VENC_DRV_MPEG_VIDEO_PROFILE_MPEG2_SNR = (1 << 11), ///< MPEG2 SNR
245 VENC_DRV_MPEG_VIDEO_PROFILE_MPEG2_SPATIAL = (1 << 12), ///< MPEG2 Spatial
246 VENC_DRV_MPEG_VIDEO_PROFILE_MPEG2_HIGH = (1 << 13), ///< MPEG2 High
247 VENC_DRV_MPEG_VIDEO_PROFILE_MPEG4_SIMPLE = (1 << 14), ///< MPEG4 Simple
248 VENC_DRV_MPEG_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE = (1 << 15), ///< MPEG4 Advanced Simple
249 VENC_DRV_MPEG_VIDEO_PROFILE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_MPEG_VIDEO_PROFILE_T value
250 } VENC_DRV_MPEG_VIDEO_PROFILE_T;
251
252
253 /**
254 * @par Enumeration
255 * VENC_DRV_MS_VIDEO_PROFILE_T
256 * @par Description
257 * This is the item used for MS encoder profile capability
258 */
259 typedef enum __VENC_DRV_MS_VIDEO_PROFILE_T
260 {
261 VENC_DRV_MS_VIDEO_PROFILE_UNKNOWN = 0, ///< Default value (not used)
262 VENC_DRV_MS_VIDEO_PROFILE_VC1_SIMPLE = (1 << 0), ///< VC1 Simple
263 VENC_DRV_MS_VIDEO_PROFILE_VC1_MAIN = (1 << 1), ///< VC1 Main
264 VENC_DRV_MS_VIDEO_PROFILE_VC1_ADVANCED = (1 << 2), ///< VC1 Advanced
265 VENC_DRV_MS_VIDEO_PROFILE_WMV9_SIMPLE = (1 << 3), ///< WMV9 Simple
266 VENC_DRV_MS_VIDEO_PROFILE_WMV9_MAIN = (1 << 4), ///< WMV9 Main
267 VENC_DRV_MS_VIDEO_PROFILE_WMV9_COMPLEX = (1 << 5), ///< WMV9 Complex
268 VENC_DRV_MS_VIDEO_PROFILE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_MS_VIDEO_PROFILE_T value
269 } VENC_DRV_MS_VIDEO_PROFILE_T;
270
271
272 /**
273 * @par Enumeration
274 * VENC_DRV_VIDEO_LEVEL_T
275 * @par Description
276 * This is the item used for encoder level capability
277 */
278 typedef enum __VENC_DRV_VIDEO_LEVEL_T
279 {
280 VENC_DRV_VIDEO_LEVEL_UNKNOWN = 0, ///< Default value (not used)
281 VENC_DRV_VIDEO_LEVEL_0, ///< VC1
282 VENC_DRV_VIDEO_LEVEL_1, ///< H264, HEVC, VC1, MPEG4
283 VENC_DRV_VIDEO_LEVEL_1b, ///< H264, HEVC
284 VENC_DRV_VIDEO_LEVEL_1_1, ///< H264, HEVC
285 VENC_DRV_VIDEO_LEVEL_1_2, ///< H264, HEVC
286 VENC_DRV_VIDEO_LEVEL_1_3, ///< H264, HEVC
287 VENC_DRV_VIDEO_LEVEL_2, ///< H264, HEVC, VC1, MPEG4
288 VENC_DRV_VIDEO_LEVEL_2_1, ///< H264, HEVC
289 VENC_DRV_VIDEO_LEVEL_2_2, ///< H264, HEVC
290 VENC_DRV_VIDEO_LEVEL_3, ///< H264, HEVC, VC1, MPEG4
291 VENC_DRV_VIDEO_LEVEL_3_1, ///< H264, HEVC
292 VENC_DRV_VIDEO_LEVEL_3_2, ///< H264, HEVC
293 VENC_DRV_VIDEO_LEVEL_4, ///< H264, HEVC, VC1
294 VENC_DRV_VIDEO_LEVEL_4_1, ///< H264, HEVC
295 VENC_DRV_VIDEO_LEVEL_4_2, ///< H264, HEVC
296 VENC_DRV_VIDEO_LEVEL_5, ///< H264, HEVC, HEVC
297 VENC_DRV_VIDEO_LEVEL_5_1, ///< H264, HEVC
298 VENC_DRV_VIDEO_LEVEL_LOW, ///< VC1, MPEG2
299 VENC_DRV_VIDEO_LEVEL_MEDIUM, ///< VC1, MPEG2
300 VENC_DRV_VIDEO_LEVEL_HIGH1440, ///< MPEG2
301 VENC_DRV_VIDEO_LEVEL_HIGH, ///< VC1, MPEG2
302 VENC_DRV_VIDEO_LEVEL_MAX = 0xFFFFFFFF ///< Max VENC_DRV_VIDEO_LEVEL_T value
303 } VENC_DRV_VIDEO_LEVEL_T;
304
305
306 /**
307 * @par Enumeration
308 * VENC_DRV_RESOLUTION_T
309 * @par Description
310 * This is the item used for encoder resolution capability
311 */
312 typedef enum __VENC_DRV_RESOLUTION_T
313 {
314 VENC_DRV_RESOLUTION_UNKNOWN = 0, ///< Default value (not used)
315 VENC_DRV_RESOLUTION_SUPPORT_QCIF, ///< CIF
316 VENC_DRV_RESOLUTION_SUPPORT_QVGA, ///< QVGA
317 VENC_DRV_RESOLUTION_SUPPORT_CIF, ///< QCIF
318 VENC_DRV_RESOLUTION_SUPPORT_HVGA, ///< HVGA: 480x320
319 VENC_DRV_RESOLUTION_SUPPORT_VGA, ///< VGA: 640x480
320 VENC_DRV_RESOLUTION_SUPPORT_480I, ///< 480I
321 VENC_DRV_RESOLUTION_SUPPORT_480P, ///< 480P
322 VENC_DRV_RESOLUTION_SUPPORT_576I, ///< 576I
323 VENC_DRV_RESOLUTION_SUPPORT_576P, ///< 480P
324 VENC_DRV_RESOLUTION_SUPPORT_FWVGA, ///< FWVGA: 864x480
325 VENC_DRV_RESOLUTION_SUPPORT_720I, ///< 720I
326 VENC_DRV_RESOLUTION_SUPPORT_720P, ///< 720P
327 VENC_DRV_RESOLUTION_SUPPORT_1080I, ///< 1080I
328 VENC_DRV_RESOLUTION_SUPPORT_1080P, ///< 1080P
329 VENC_DRV_RESOLUTION_SUPPORT_2160P, ///< 2160P
330 VENC_DRV_RESOLUTION_SUPPORT_MAX = 0xFFFFFFFF ///< Max VENC_DRV_RESOLUTION_T value
331 } VENC_DRV_RESOLUTION_T;
332
333
334 /**
335 * @par Enumeration
336 * VENC_DRV_SET_TYPE_T
337 * @par Description
338 * This is the input parameter for eVEncDrvSetParam()
339 */
340 typedef enum __VENC_DRV_SET_TYPE_T
341 {
342 VENC_DRV_SET_TYPE_UNKONW = 0, ///< Default value (not used)
343 VENC_DRV_SET_TYPE_RST, ///< Set reset
344 VENC_DRV_SET_TYPE_CB, ///< Set callback function
345 VENC_DRV_SET_TYPE_PARAM_RC, ///< Set rate control parameter
346 VENC_DRV_SET_TYPE_PARAM_ME, ///< Set motion estimation parameter
347 VENC_DRV_SET_TYPE_PARAM_EIS, ///< Set EIS parameter
348 VENC_DRV_SET_TYPE_PARAM_ENC, ///< Set encoder parameters such as I-frame period, etc.
349 VENC_DRV_SET_TYPE_STATISTIC_ON, ///< Enable statistic function
350 VENC_DRV_SET_TYPE_STATISTIC_OFF, ///< Disable statistic function
351 VENC_DRV_SET_TYPE_SET_OMX_TIDS, ///< Set OMX thread IDs
352 VENC_DRV_SET_TYPE_MPEG4_SHORT, ///< Set MPEG4 short header mode
353 VENC_DRV_SET_TYPE_FORCE_INTRA_ON, ///< Set Force Intra Frame on
354 VENC_DRV_SET_TYPE_FORCE_INTRA_OFF, ///< Set Force Intra Frame off
355 VENC_DRV_SET_TYPE_TIME_LAPSE, ///< Set time lapse
356 VENC_DRV_SET_TYPE_ALLOC_WORK_BUF, ///< Set to alloc working buffer
357 VENC_DRV_SET_TYPE_DUMP_WORK_BUF, ///< Set to dump working buffer
358 VENC_DRV_SET_TYPE_FREE_WORK_BUF, ///< Set to free working buffer
359 VENC_DRV_SET_TYPE_ADJUST_BITRATE, ///< Set to adjust bitrate
360 VENC_DRV_SET_TYPE_I_FRAME_INTERVAL, ///< Set I Frame interval
361 VENC_DRV_SET_TYPE_WFD_MODE, ///< Set Wifi-Display Mode
362 VENC_DRV_SET_TYPE_RECORD_SIZE, ///< Ser record size
363 VENC_DRV_SET_TYPE_USE_MCI_BUF, ///< Set to use MCI buffer
364 VENC_DRV_SET_TYPE_ADJUST_FRAMERATE, ///< Set frame rate
365 VENC_DRV_SET_TYPE_INIT_QP, ///< Set init QP
366 VENC_DRV_SET_TYPE_SKIP_FRAME, ///< Set skip one frame
367 VENC_DRV_SET_TYPE_SCENARIO, ///< Set VENC Scenario
368 VENC_DRV_SET_TYPE_PREPEND_HEADER, ///< Set prepend SPS/PPS before IDR
369 VENC_DRV_SET_TYPE_SLOW_MOTION_ENCODE, ///< Set to Slow Motion Video Recording for header or frame
370 VENC_DRV_SET_TYPE_SLOW_MOTION_POST_PROC, ///< Set to Slow Motion Video Recording for encoded bs with post processing
371 VENC_DRV_SET_TYPE_SLOW_MOTION_LOCK_HW, ///< Set to Slow Motion Video Recording for Lock HW
372 VENC_DRV_SET_TYPE_SLOW_MOTION_UNLOCK_HW, ///< Set to Slow Motion Video Recording for UnLock HW
373 VENC_DRV_SET_TYPE_NONREFP, ///< Set Enable/Disable Non reference P frame
374 VENC_DRV_SET_TYPE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_SET_TYPE_T value
375 } VENC_DRV_SET_TYPE_T;
376
377
378 /**
379 * @par Enumeration
380 * VENC_DRV_GET_TYPE_T
381 * @par Description
382 * This is the input parameter for eVEncDrvGetParam()
383 */
384 typedef enum __VENC_DRV_GET_TYPE_T
385 {
386 VENC_DRV_GET_TYPE_UNKONW = 0, ///< Default value (not used)
387 VENC_DRV_GET_TYPE_PARAM_RC, ///< Get rate control parameter
388 VENC_DRV_GET_TYPE_PARAM_ME, ///< Get motion estimation parameter
389 VENC_DRV_GET_TYPE_PARAM_EIS, ///< Get EIS parameter
390 VENC_DRV_GET_TYPE_PARAM_ENC, ///< Get encoder parameters such as I-frame period, etc.
391 VENC_DRV_GET_TYPE_STATISTIC, ///< Get statistic.
392 VENC_DRV_GET_TYPE_GET_CPU_LOADING_INFO, ///< query the cpu loading info from kernel driver
393 VENC_DRV_GET_TYPE_GET_YUV_FORMAT, ///< Get YUV format
394 VENC_DRV_GET_TYPE_GET_CODEC_TIDS,
395 /* for DirectLink Meta Mode + */
396 VENC_DRV_GET_TYPE_ALLOC_META_HANDLE_LIST, ///< Alloc a handle to store meta handle list
397 VENC_DRV_GET_TYPE_GET_BUF_INFO_FROM_META_HANDLE, ///< Get buffer virtual address from meta buffer handle
398 VENC_DRV_GET_TYPE_FREE_META_HANDLE_LIST, ///< free a handle allocated from VENC_DRV_GET_TYPE_ALLOC_META_HANDLE_LIST
399 /* for DirectLink Meta Mode - */
400 VENC_DRV_GET_TYPE_MAX = 0xFFFFFFFF ///< Max VENC_DRV_GET_TYPE_MAX value
401 } VENC_DRV_GET_TYPE_T;
402
403
404 /**
405 * @par Enumeration
406 * VENC_DRV_MRESULT_T
407 * @par Description
408 * This is the return value for eVEncDrvXXX()
409 */
410 typedef enum __VENC_DRV_MRESULT_T
411 {
412 VENC_DRV_MRESULT_OK = 0, ///< Return Success
413 VENC_DRV_MRESULT_FAIL, ///< Return Fail
414 VENC_DRV_MRESULT_MAX = 0x0FFFFFFF ///< Max VENC_DRV_MRESULT_T value
415 } VENC_DRV_MRESULT_T;
416
417
418 /**
419 * @par Enumeration
420 * VENC_DRV_SCENARIO_T
421 * @par Description
422 * This is the scenario for VENC scenario
423 */
424 typedef enum __VENC_DRV_SCENARIO_T
425 {
426 VENC_DRV_SCENARIO_CAMERA_REC = 1, ///< Camera recording
427 VENC_DRV_SCENARIO_LIVEPHOTO_CAPTURE = (1 << 1), ///< LivePhoto recording
428 VENC_DRV_SCENARIO_LIVEPHOTO_EFFECT = (1 << 2), ///< LivePhoto effect transcoding
429 VENC_DRV_SCENARIO_CAMERA_REC_SLOW_MOTION = (1 << 3), ///< Camera recording with slow motion
430 VENC_DRV_SCENARIO_SCREEN_REC = (1 << 4), ///< Screen recording
431 } VENC_DRV_SCENARIO_T;
432
433
434 /**
435 * @par Structure
436 * VENC_DRV_QUERY_VIDEO_FORMAT_T
437 * @par Description
438 * This is a input parameter for eVEncDrvQueryCapability()
439 */
440 typedef struct __VENC_DRV_QUERY_VIDEO_FORMAT_T
441 {
442 VENC_DRV_VIDEO_FORMAT_T eVideoFormat; ///< [OUT] video format capability
443 VAL_UINT32_T u4Profile; ///< [OUT] video profile capability (VENC_DRV_H264_VIDEO_PROFILE_T, VENC_DRV_MPEG_VIDEO_PROFILE_T, VENC_DRV_MS_VIDEO_PROFILE_T)
444 VENC_DRV_VIDEO_LEVEL_T eLevel; ///< [OUT] video level capability
445 VENC_DRV_RESOLUTION_T eResolution; ///< [OUT] video resolution capability
446 VAL_UINT32_T u4Width; ///< [OUT] video width capability
447 VAL_UINT32_T u4Height; ///< [OUT] video height capability
448 VAL_UINT32_T u4Bitrate; ///< [OUT] video bitrate capability
449 VAL_UINT32_T u4FrameRate; ///< [OUT] video FrameRate capability, 15, 30,...
450 } VENC_DRV_QUERY_VIDEO_FORMAT_T;
451
452 /**
453 * @par Structure
454 * P_VENC_DRV_QUERY_VIDEO_FORMAT_T
455 * @par Description
456 * This is the pointer of VENC_DRV_QUERY_VIDEO_FORMAT_T
457 */
458 typedef VENC_DRV_QUERY_VIDEO_FORMAT_T *P_VENC_DRV_QUERY_VIDEO_FORMAT_T;
459
460
461 /**
462 * @par Structure
463 * VENC_DRV_QUERY_INPUT_BUF_LIMIT
464 * @par Description
465 * This is a input parameter for eVEncDrvQueryCapability()
466 */
467 typedef struct __VENC_DRV_QUERY_INPUT_BUF_LIMIT
468 {
469 VENC_DRV_VIDEO_FORMAT_T eVideoFormat; ///< [IN] video format
470 VAL_UINT32_T u4Width; ///< [IN] video width
471 VAL_UINT32_T u4Height; ///< [IN] video height
472 VAL_UINT32_T u4Stride; ///< [OUT] video stride
473 VAL_UINT32_T u4SliceHeight; ///< [OUT] video sliceheight
474 VENC_DRV_SCENARIO_T eScenario; ///< [IN] venc scenario
475 } VENC_DRV_QUERY_INPUT_BUF_LIMIT;
476
477
478 /**
479 * @par Structure
480 * VENC_DRV_PARAM_ENC_T
481 * @par Description
482 * This is the encoder settings and used as input or output parameter for eVEncDrvSetParam() or eVEncDrvGetParam()
483 */
484 typedef struct __VENC_DRV_PARAM_ENC_T
485 {
486 VENC_DRV_YUV_FORMAT_T eVEncFormat; ///< [IN/OUT] YUV format
487 VAL_UINT32_T u4Profile; ///< [IN/OUT] Profile
488 VAL_UINT32_T u4Level; ///< [IN/OUT] Level
489 VAL_UINT32_T u4Width; ///< [IN/OUT] Image Width
490 VAL_UINT32_T u4Height; ///< [IN/OUT] Image Height
491 VAL_UINT32_T u4BufWidth; ///< [IN/OUT] Buffer Width
492 VAL_UINT32_T u4BufHeight; ///< [IN/OUT] Buffer Heigh
493 VAL_UINT32_T u4NumPFrm; ///< [IN/OUT] The number of P frame between two I frame.
494 VAL_UINT32_T u4NumBFrm; ///< [IN/OUT] The number of B frame between two reference frame.
495 VENC_DRV_FRAME_RATE_T eFrameRate; ///< [IN/OUT] Frame rate
496 VAL_BOOL_T fgInterlace; ///< [IN/OUT] Interlace coding.
497 VAL_VOID_T *pvExtraEnc; ///< [IN/OUT] For VENC_DRV_PARAM_ENC_H264_T or ...
498 VAL_MEMORY_T rExtraEncMem; ///< [IN/OUT] Extra Encoder Memory Info
499 VAL_BOOL_T fgUseMCI; ///< [IN/OUT] Use MCI
500 VAL_BOOL_T fgMultiSlice; ///< [IN/OUT] Is multi-slice bitstream ?
501 } VENC_DRV_PARAM_ENC_T;
502
503 /**
504 * @par Structure
505 * P_VENC_DRV_PARAM_ENC_T
506 * @par Description
507 * This is the pointer of VENC_DRV_PARAM_ENC_T
508 */
509 typedef VENC_DRV_PARAM_ENC_T *P_VENC_DRV_PARAM_ENC_T;
510
511
512 /**
513 * @par Structure
514 * VENC_DRV_PARAM_ENC_EXTRA_T
515 * @par Description
516 * This is the encoder settings and used as input or output parameter for eVEncDrvSetParam() or eVEncDrvGetParam()
517 */
518 typedef struct __VENC_DRV_PARAM_ENC_EXTRA_T
519 {
520 VAL_UINT32_T u4IntraFrameRate; ///< [IN/OUT] Intra frame rate
521 VAL_UINT32_T u4BitRate; ///< [IN/OUT] BitRate kbps
522 VAL_UINT32_T u4FrameRateQ16; ///< [IN/OUT] Frame rate in Q16 format
523 VAL_UINT32_T u4UseMBAFF; ///< [IN/OUT] Use MBAFF
524 } VENC_DRV_PARAM_ENC_EXTRA_T;
525
526 /**
527 * @par Structure
528 * P_VENC_DRV_PARAM_ENC_EXTRA_T
529 * @par Description
530 * This is the pointer of VENC_DRV_PARAM_ENC_EXTRA_T
531 */
532 typedef VENC_DRV_PARAM_ENC_EXTRA_T *pVENC_DRV_PARAM_ENC_EXTRA_T;
533
534
535 #define VENC_DRV_VDO_PROP_LIST_MAX (64)
536
537 /**
538 * @par Structure
539 * VENC_DRV_VIDEO_PROPERTY_T
540 * @par Description
541 * This is used to get the "target bitrate" according to "resolution and frame rate"
542 */
543 typedef struct __VENC_DRV_VIDEO_PROPERTY_T
544 {
545 VENC_DRV_VIDEO_FORMAT_T eVideoFormat;
546 VAL_UINT32_T u4Width;
547 VAL_UINT32_T u4Height;
548 VAL_UINT32_T u4FrameRate;
549 VAL_UINT32_T u4BitRate; // used for query table
550 VAL_BOOL_T fgPropIsValid;
551 } VENC_DRV_VIDEO_PROPERTY_T;
552
553 /**
554 * @par Structure
555 * P_VENC_DRV_VIDEO_PROPERTY_T
556 * @par Description
557 * This is the pointer of VENC_DRV_VIDEO_PROPERTY_T
558 */
559 typedef VENC_DRV_VIDEO_PROPERTY_T *P_VENC_DRV_VIDEO_PROPERTY_T;
560
561
562 /**
563 * @par Structure
564 * VENC_DRV_TIMESTAMP_T
565 * @par Description
566 * This is timestamp information and used as items for VENC_DRV_PARAM_FRM_BUF_T and VENC_DRV_PARAM_BS_BUF_T
567 */
568 typedef struct __VENC_DRV_TIMESTAMP_T
569 {
570 VAL_UINT32_T u4TimeStamp[2]; ///< [IN] Timestamp information
571 } VENC_DRV_TIMESTAMP_T;
572
573 /**
574 * @par Structure
575 * P_VENC_DRV_TIMESTAMP_T
576 * @par Description
577 * This is the pointer of VENC_DRV_TIMESTAMP_T
578 */
579 typedef VENC_DRV_TIMESTAMP_T *P_VENC_DRV_TIMESTAMP_T;
580
581
582 /**
583 * @par Structure
584 * VENC_DRV_EIS_INPUT_T
585 * @par Description
586 * This is EIS information and used as items for VENC_DRV_PARAM_FRM_BUF_T
587 */
588 typedef struct __VENC_DRV_EIS_INPUT_T
589 {
590 VAL_UINT32_T u4X; ///< [IN] Start coordination X
591 VAL_UINT32_T u4Y; ///< [IN] Start coordination Y
592 } VENC_DRV_EIS_INPUT_T;
593
594 /**
595 * @par Structure
596 * P_VENC_DRV_EIS_INPUT_T
597 * @par Description
598 * This is the pointer of VENC_DRV_EIS_INPUT_T
599 */
600 typedef VENC_DRV_EIS_INPUT_T *P_VENC_DRV_EIS_INPUT_T;
601
602
603 /**
604 * @par Structure
605 * VENC_DRV_PARAM_FRM_BUF_T
606 * @par Description
607 * This is frame buffer information and used as input parameter for eVEncDrvEncode()
608 */
609 typedef struct __VENC_DRV_PARAM_FRM_BUF_T
610 {
611 VAL_MEM_ADDR_T rFrmBufAddr; ///< [IN] Frame buffer address
612 VAL_MEM_ADDR_T rCoarseAddr; ///< [IN] Coarse address
613 VENC_DRV_TIMESTAMP_T rTimeStamp; ///< [IN] Timestamp information
614 VENC_DRV_EIS_INPUT_T rEISInput; ///< [IN] EIS information
615 VAL_UINT32_T rSecMemHandle; ///< [IN/OUT] security memory handle for SVP
616 } VENC_DRV_PARAM_FRM_BUF_T;
617
618 /**
619 * @par Structure
620 * P_VENC_DRV_PARAM_FRM_BUF_T
621 * @par Description
622 * This is the pointer of VENC_DRV_PARAM_FRM_BUF_T
623 */
624 typedef VENC_DRV_PARAM_FRM_BUF_T *P_VENC_DRV_PARAM_FRM_BUF_T;
625
626
627 /**
628 * @par Structure
629 * VENC_DRV_PARAM_BS_BUF_T
630 * @par Description
631 * This is bitstream buffer information and used as input parameter for\n
632 * eVEncDrvEncode()\n
633 */
634 typedef struct __VENC_DRV_PARAM_BS_BUF_T
635 {
636 VAL_MEM_ADDR_T rBSAddr; ///< [IN] Bitstream buffer address
637 VAL_ULONG_T u4BSStartVA; ///< [IN] Bitstream fill start address
638 VAL_ULONG_T u4BSSize; ///< [IN] Bitstream size (filled bitstream in bytes)
639 VENC_DRV_TIMESTAMP_T rTimeStamp; ///< [IN] Time stamp information
640 VAL_UINT32_T rSecMemHandle; ///< [IN/OUT] security memory handle for SVP
641 } VENC_DRV_PARAM_BS_BUF_T;
642
643 /**
644 * @par Structure
645 * P_VENC_DRV_PARAM_BS_BUF_T
646 * @par Description
647 * This is the pointer of VENC_DRV_PARAM_BS_BUF_T
648 */
649 typedef VENC_DRV_PARAM_BS_BUF_T *P_VENC_DRV_PARAM_BS_BUF_T;
650
651
652 /**
653 * @par Structure
654 * VENC_DRV_DONE_RESULT_T
655 * @par Description
656 * This is callback and return information and used as output parameter for eVEncDrvEncode()
657 */
658 typedef struct __VENC_DRV_DONE_RESULT_T
659 {
660 VENC_DRV_MESSAGE_T eMessage; ///< [OUT] Message, such as success or error code
661 P_VENC_DRV_PARAM_BS_BUF_T prBSBuf; ///< [OUT] Bitstream information
662 P_VENC_DRV_PARAM_FRM_BUF_T prFrmBuf; ///< [OUT] Input frame buffer information. if address is null, don't use this buffer, else reuse
663 VAL_BOOL_T fgIsKeyFrm; ///< [OUT] output is key frame or not
664 VAL_UINT32_T u4HWEncodeTime; ///< [OUT] HW encode Time
665 } VENC_DRV_DONE_RESULT_T;
666
667 /**
668 * @par Structure
669 * P_VENC_DRV_DONE_RESULT_T
670 * @par Description
671 * This is the pointer of VENC_DRV_DONE_RESULT_T
672 */
673 typedef VENC_DRV_DONE_RESULT_T *P_VENC_DRV_DONE_RESULT_T;
674
675
676 /**
677 * @par Structure
678 * VENC_DRV_PROPERTY_T
679 * @par Description
680 * This is property information and used as output parameter for eVEncDrvQueryCapability()
681 */
682 typedef struct __VENC_DRV_PROPERTY_T
683 {
684 VAL_UINT32_T u4BufAlign; ///< [OUT] Buffer alignment requirement
685 VAL_UINT32_T u4BufUnitSize; ///< [OUT] Buffer unit size is N bytes (e.g., 8, 16, or 64 bytes per unit.)
686 VAL_UINT32_T u4ExtraBufSize; ///< [OUT] Extra buffer size in initial stage
687 VAL_BOOL_T fgOutputRingBuf; ///< [OUT] Output is ring buffer
688 VAL_BOOL_T fgCoarseMESupport; ///< [OUT] Support ME coarse search
689 VAL_BOOL_T fgEISSupport; ///< [OUT] Support EIS
690 } VENC_DRV_PROPERTY_T;
691
692 /**
693 * @par Structure
694 * P_VENC_DRV_PROPERTY_T
695 * @par Description
696 * This is the pointer of VENC_DRV_PROPERTY_T
697 */
698 typedef VENC_DRV_PROPERTY_T *P_VENC_DRV_PROPERTY_T;
699
700
701 /**
702 * @par Function
703 * eVEncDrvQueryCapability
704 * @par Description
705 * Query the driver capability
706 * @param
707 * a_eType [IN/OUT] The VENC_DRV_QUERY_TYPE_T structure
708 * @param
709 * a_pvInParam [IN] The input parameter
710 * @param
711 * a_pvOutParam [OUT] The output parameter
712 * @par Returns
713 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
714 */
715 VENC_DRV_MRESULT_T eVEncDrvQueryCapability(
716 VENC_DRV_QUERY_TYPE_T a_eType,
717 VAL_VOID_T *a_pvInParam,
718 VAL_VOID_T *a_pvOutParam
719 );
720
721
722 /**
723 * @par Function
724 * eVEncDrvCreate
725 * @par Description
726 * Create the driver handle
727 * @param
728 * a_phHandle [OUT] The driver handle
729 * @param
730 * a_eVideoFormat [IN] The VENC_DRV_VIDEO_FORMAT_T structure
731 * @par Returns
732 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
733 */
734 VENC_DRV_MRESULT_T eVEncDrvCreate(
735 VAL_HANDLE_T *a_phHandle,
736 VENC_DRV_VIDEO_FORMAT_T a_eVideoFormat
737 );
738
739
740 /**
741 * @par Function
742 * eVEncDrvRelease
743 * @par Description
744 * Release the driver handle
745 * @param
746 * a_hHandle [IN] The driver handle
747 * @param
748 * a_eVideoFormat [IN] The VENC_DRV_VIDEO_FORMAT_T structure
749 * @par Returns
750 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
751 */
752 VENC_DRV_MRESULT_T eVEncDrvRelease(
753 VAL_HANDLE_T a_hHandle,
754 VENC_DRV_VIDEO_FORMAT_T a_eVideoFormat
755 );
756
757
758 /**
759 * @par Function
760 * eVEncDrvInit
761 * @par Description
762 * Init the driver setting, alloc working memory ... etc.
763 * @param
764 * a_hHandle [IN] The driver handle
765 * @par Returns
766 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
767 */
768 VENC_DRV_MRESULT_T eVEncDrvInit(
769 VAL_HANDLE_T a_hHandle
770 );
771
772 /**
773 * @par Function
774 * eVEncDrvDeInit
775 * @par Description
776 * DeInit the driver setting, free working memory ... etc.
777 * @param
778 * a_hHandle [IN] The driver handle
779 * @par Returns
780 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
781 */
782 VENC_DRV_MRESULT_T eVEncDrvDeInit(
783 VAL_HANDLE_T a_hHandle
784 );
785
786
787 /**
788 * @par Function
789 * eVEncDrvSetParam
790 * @par Description
791 * Set parameter to driver
792 * @param
793 * a_hHandle [IN] The driver handle
794 * @param
795 * a_eType [IN] The VENC_DRV_SET_TYPE_T structure
796 * @param
797 * a_pvInParam [IN] The input parameter
798 * @param
799 * a_pvOutParam [OUT] The output parameter
800 * @par Returns
801 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
802 */
803 VENC_DRV_MRESULT_T eVEncDrvSetParam(
804 VAL_HANDLE_T a_hHandle,
805 VENC_DRV_SET_TYPE_T a_eType,
806 VAL_VOID_T *a_pvInParam,
807 VAL_VOID_T *a_pvOutParam
808 );
809
810
811 /**
812 * @par Function
813 * eVEncDrvGetParam
814 * @par Description
815 * Get parameter from driver
816 * @param
817 * a_hHandle [IN] The driver handle
818 * @param
819 * a_eType [IN] The VENC_DRV_SET_TYPE_T structure
820 * @param
821 * a_pvInParam [IN] The input parameter
822 * @param
823 * a_pvOutParam [OUT] The output parameter
824 * @par Returns
825 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
826 */
827 VENC_DRV_MRESULT_T eVEncDrvGetParam(
828 VAL_HANDLE_T a_hHandle,
829 VENC_DRV_GET_TYPE_T a_eType,
830 VAL_VOID_T *a_pvInParam,
831 VAL_VOID_T *a_pvOutParam
832 );
833
834
835 /**
836 * @par Function
837 * eVEncDrvEncode
838 * @par Description
839 * Encode frame
840 * @param
841 * a_hHandle [IN] The driver handle
842 * @param
843 * a_eOpt [IN] The VENC_DRV_START_OPT_T structure
844 * @param
845 * a_prFrmBuf [IN] The input frame buffer with VENC_DRV_PARAM_FRM_BUF_T structure
846 * @param
847 * a_prBSBuf [IN] The input bitstream buffer with VENC_DRV_PARAM_BS_BUF_T structure
848 * @param
849 * a_prResult [OUT] The output result with VENC_DRV_DONE_RESULT_T structure
850 * @par Returns
851 * VENC_DRV_MRESULT_T [OUT] VENC_DRV_MRESULT_OK for success, VENC_DRV_MRESULT_FAIL for fail
852 */
853 VENC_DRV_MRESULT_T eVEncDrvEncode(
854 VAL_HANDLE_T a_hHandle,
855 VENC_DRV_START_OPT_T a_eOpt,
856 VENC_DRV_PARAM_FRM_BUF_T *a_prFrmBuf,
857 VENC_DRV_PARAM_BS_BUF_T *a_prBSBuf,
858 VENC_DRV_DONE_RESULT_T *a_prResult
859 );
860
861
862 #ifdef __cplusplus
863 }
864 #endif
865
866 #endif // #ifndef _VENC_DRV_IF_PUBLIC_H_
kernel source for telekom puls (alcatel/mediatek)