|
1 /** |
|
2 * Copyright (c) 2008 The Khronos Group Inc. |
|
3 * |
|
4 * Permission is hereby granted, free of charge, to any person obtaining |
|
5 * a copy of this software and associated documentation files (the |
|
6 * "Software"), to deal in the Software without restriction, including |
|
7 * without limitation the rights to use, copy, modify, merge, publish, |
|
8 * distribute, sublicense, and/or sell copies of the Software, and to |
|
9 * permit persons to whom the Software is furnished to do so, subject |
|
10 * to the following conditions: |
|
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 |
|
16 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
|
17 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
|
18 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
|
19 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
|
20 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
21 * |
|
22 */ |
|
23 |
|
24 /** |
|
25 * @file OMX_Video.h - OpenMax IL version 1.1.2 |
|
26 * The structures is needed by Video components to exchange parameters |
|
27 * and configuration data with OMX components. |
|
28 */ |
|
29 #ifndef OMX_Video_h |
|
30 #define OMX_Video_h |
|
31 |
|
32 /** @defgroup video OpenMAX IL Video Domain |
|
33 * @ingroup iv |
|
34 * Structures for OpenMAX IL Video domain |
|
35 * @{ |
|
36 */ |
|
37 |
|
38 #ifdef __cplusplus |
|
39 extern "C" { |
|
40 #endif /* __cplusplus */ |
|
41 |
|
42 |
|
43 /** |
|
44 * Each OMX header must include all required header files to allow the |
|
45 * header to compile without errors. The includes below are required |
|
46 * for this header file to compile successfully |
|
47 */ |
|
48 |
|
49 #include <openmax/il/khronos/v1_x/OMX_IVCommon.h> |
|
50 |
|
51 |
|
52 /** |
|
53 * Enumeration used to define the possible video compression codings. |
|
54 * NOTE: This essentially refers to file extensions. If the coding is |
|
55 * being used to specify the ENCODE type, then additional work |
|
56 * must be done to configure the exact flavor of the compression |
|
57 * to be used. For decode cases where the user application can |
|
58 * not differentiate between MPEG-4 and H.264 bit streams, it is |
|
59 * up to the codec to handle this. |
|
60 */ |
|
61 typedef enum OMX_VIDEO_CODINGTYPE { |
|
62 OMX_VIDEO_CodingUnused, /**< Value when coding is N/A */ |
|
63 OMX_VIDEO_CodingAutoDetect, /**< Autodetection of coding type */ |
|
64 OMX_VIDEO_CodingMPEG2, /**< AKA: H.262 */ |
|
65 OMX_VIDEO_CodingH263, /**< H.263 */ |
|
66 OMX_VIDEO_CodingMPEG4, /**< MPEG-4 */ |
|
67 OMX_VIDEO_CodingWMV, /**< all versions of Windows Media Video */ |
|
68 OMX_VIDEO_CodingRV, /**< all versions of Real Video */ |
|
69 OMX_VIDEO_CodingAVC, /**< H.264/AVC */ |
|
70 OMX_VIDEO_CodingMJPEG, /**< Motion JPEG */ |
|
71 OMX_VIDEO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
72 OMX_VIDEO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
73 OMX_VIDEO_CodingMax = 0x7FFFFFFF |
|
74 } OMX_VIDEO_CODINGTYPE; |
|
75 |
|
76 |
|
77 /** |
|
78 * Data structure used to define a video path. The number of Video paths for |
|
79 * input and output will vary by type of the Video component. |
|
80 * |
|
81 * Input (aka Source) : zero Inputs, one Output, |
|
82 * Splitter : one Input, 2 or more Outputs, |
|
83 * Processing Element : one Input, one output, |
|
84 * Mixer : 2 or more inputs, one output, |
|
85 * Output (aka Sink) : one Input, zero outputs. |
|
86 * |
|
87 * The PortDefinition structure is used to define all of the parameters |
|
88 * necessary for the compliant component to setup an input or an output video |
|
89 * path. If additional vendor specific data is required, it should be |
|
90 * transmitted to the component using the CustomCommand function. Compliant |
|
91 * components will prepopulate this structure with optimal values during the |
|
92 * GetDefaultInitParams command. |
|
93 * |
|
94 * STRUCT MEMBERS: |
|
95 * cMIMEType : MIME type of data for the port |
|
96 * pNativeRender : Platform specific reference for a display if a |
|
97 * sync, otherwise this field is 0 |
|
98 * nFrameWidth : Width of frame to be used on channel if |
|
99 * uncompressed format is used. Use 0 for unknown, |
|
100 * don't care or variable |
|
101 * nFrameHeight : Height of frame to be used on channel if |
|
102 * uncompressed format is used. Use 0 for unknown, |
|
103 * don't care or variable |
|
104 * nStride : Number of bytes per span of an image |
|
105 * (i.e. indicates the number of bytes to get |
|
106 * from span N to span N+1, where negative stride |
|
107 * indicates the image is bottom up |
|
108 * nSliceHeight : Height used when encoding in slices |
|
109 * nBitrate : Bit rate of frame to be used on channel if |
|
110 * compressed format is used. Use 0 for unknown, |
|
111 * don't care or variable |
|
112 * xFramerate : Frame rate to be used on channel if uncompressed |
|
113 * format is used. Use 0 for unknown, don't care or |
|
114 * variable. Units are Q16 frames per second. |
|
115 * bFlagErrorConcealment : Turns on error concealment if it is supported by |
|
116 * the OMX component |
|
117 * eCompressionFormat : Compression format used in this instance of the |
|
118 * component. When OMX_VIDEO_CodingUnused is |
|
119 * specified, eColorFormat is used |
|
120 * eColorFormat : Decompressed format used by this component |
|
121 * pNativeWindow : Platform specific reference for a window object if a |
|
122 * display sink , otherwise this field is 0x0. |
|
123 */ |
|
124 typedef struct OMX_VIDEO_PORTDEFINITIONTYPE { |
|
125 OMX_STRING cMIMEType; |
|
126 OMX_NATIVE_DEVICETYPE pNativeRender; |
|
127 OMX_U32 nFrameWidth; |
|
128 OMX_U32 nFrameHeight; |
|
129 OMX_S32 nStride; |
|
130 OMX_U32 nSliceHeight; |
|
131 OMX_U32 nBitrate; |
|
132 OMX_U32 xFramerate; |
|
133 OMX_BOOL bFlagErrorConcealment; |
|
134 OMX_VIDEO_CODINGTYPE eCompressionFormat; |
|
135 OMX_COLOR_FORMATTYPE eColorFormat; |
|
136 OMX_NATIVE_WINDOWTYPE pNativeWindow; |
|
137 } OMX_VIDEO_PORTDEFINITIONTYPE; |
|
138 |
|
139 /** |
|
140 * Port format parameter. This structure is used to enumerate the various |
|
141 * data input/output format supported by the port. |
|
142 * |
|
143 * STRUCT MEMBERS: |
|
144 * nSize : Size of the structure in bytes |
|
145 * nVersion : OMX specification version information |
|
146 * nPortIndex : Indicates which port to set |
|
147 * nIndex : Indicates the enumeration index for the format from |
|
148 * 0x0 to N-1 |
|
149 * eCompressionFormat : Compression format used in this instance of the |
|
150 * component. When OMX_VIDEO_CodingUnused is specified, |
|
151 * eColorFormat is used |
|
152 * eColorFormat : Decompressed format used by this component |
|
153 * xFrameRate : Indicates the video frame rate in Q16 format |
|
154 */ |
|
155 typedef struct OMX_VIDEO_PARAM_PORTFORMATTYPE { |
|
156 OMX_U32 nSize; |
|
157 OMX_VERSIONTYPE nVersion; |
|
158 OMX_U32 nPortIndex; |
|
159 OMX_U32 nIndex; |
|
160 OMX_VIDEO_CODINGTYPE eCompressionFormat; |
|
161 OMX_COLOR_FORMATTYPE eColorFormat; |
|
162 OMX_U32 xFramerate; |
|
163 } OMX_VIDEO_PARAM_PORTFORMATTYPE; |
|
164 |
|
165 |
|
166 /** |
|
167 * This is a structure for configuring video compression quantization |
|
168 * parameter values. Codecs may support different QP values for different |
|
169 * frame types. |
|
170 * |
|
171 * STRUCT MEMBERS: |
|
172 * nSize : Size of the structure in bytes |
|
173 * nVersion : OMX specification version info |
|
174 * nPortIndex : Port that this structure applies to |
|
175 * nQpI : QP value to use for index frames |
|
176 * nQpP : QP value to use for P frames |
|
177 * nQpB : QP values to use for bidirectional frames |
|
178 */ |
|
179 typedef struct OMX_VIDEO_PARAM_QUANTIZATIONTYPE { |
|
180 OMX_U32 nSize; |
|
181 OMX_VERSIONTYPE nVersion; |
|
182 OMX_U32 nPortIndex; |
|
183 OMX_U32 nQpI; |
|
184 OMX_U32 nQpP; |
|
185 OMX_U32 nQpB; |
|
186 } OMX_VIDEO_PARAM_QUANTIZATIONTYPE; |
|
187 |
|
188 |
|
189 /** |
|
190 * Structure for configuration of video fast update parameters. |
|
191 * |
|
192 * STRUCT MEMBERS: |
|
193 * nSize : Size of the structure in bytes |
|
194 * nVersion : OMX specification version info |
|
195 * nPortIndex : Port that this structure applies to |
|
196 * bEnableVFU : Enable/Disable video fast update |
|
197 * nFirstGOB : Specifies the number of the first macroblock row |
|
198 * nFirstMB : specifies the first MB relative to the specified first GOB |
|
199 * nNumMBs : Specifies the number of MBs to be refreshed from nFirstGOB |
|
200 * and nFirstMB |
|
201 */ |
|
202 typedef struct OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE { |
|
203 OMX_U32 nSize; |
|
204 OMX_VERSIONTYPE nVersion; |
|
205 OMX_U32 nPortIndex; |
|
206 OMX_BOOL bEnableVFU; |
|
207 OMX_U32 nFirstGOB; |
|
208 OMX_U32 nFirstMB; |
|
209 OMX_U32 nNumMBs; |
|
210 } OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE; |
|
211 |
|
212 |
|
213 /** |
|
214 * Enumeration of possible bitrate control types |
|
215 */ |
|
216 typedef enum OMX_VIDEO_CONTROLRATETYPE { |
|
217 OMX_Video_ControlRateDisable, |
|
218 OMX_Video_ControlRateVariable, |
|
219 OMX_Video_ControlRateConstant, |
|
220 OMX_Video_ControlRateVariableSkipFrames, |
|
221 OMX_Video_ControlRateConstantSkipFrames, |
|
222 OMX_Video_ControlRateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
223 OMX_Video_ControlRateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
224 OMX_Video_ControlRateMax = 0x7FFFFFFF |
|
225 } OMX_VIDEO_CONTROLRATETYPE; |
|
226 |
|
227 |
|
228 /** |
|
229 * Structure for configuring bitrate mode of a codec. |
|
230 * |
|
231 * STRUCT MEMBERS: |
|
232 * nSize : Size of the struct in bytes |
|
233 * nVersion : OMX spec version info |
|
234 * nPortIndex : Port that this struct applies to |
|
235 * eControlRate : Control rate type enum |
|
236 * nTargetBitrate : Target bitrate to encode with |
|
237 */ |
|
238 typedef struct OMX_VIDEO_PARAM_BITRATETYPE { |
|
239 OMX_U32 nSize; |
|
240 OMX_VERSIONTYPE nVersion; |
|
241 OMX_U32 nPortIndex; |
|
242 OMX_VIDEO_CONTROLRATETYPE eControlRate; |
|
243 OMX_U32 nTargetBitrate; |
|
244 } OMX_VIDEO_PARAM_BITRATETYPE; |
|
245 |
|
246 |
|
247 /** |
|
248 * Enumeration of possible motion vector (MV) types |
|
249 */ |
|
250 typedef enum OMX_VIDEO_MOTIONVECTORTYPE { |
|
251 OMX_Video_MotionVectorPixel, |
|
252 OMX_Video_MotionVectorHalfPel, |
|
253 OMX_Video_MotionVectorQuarterPel, |
|
254 OMX_Video_MotionVectorEighthPel, |
|
255 OMX_Video_MotionVectorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
256 OMX_Video_MotionVectorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
257 OMX_Video_MotionVectorMax = 0x7FFFFFFF |
|
258 } OMX_VIDEO_MOTIONVECTORTYPE; |
|
259 |
|
260 |
|
261 /** |
|
262 * Structure for configuring the number of motion vectors used as well |
|
263 * as their accuracy. |
|
264 * |
|
265 * STRUCT MEMBERS: |
|
266 * nSize : Size of the struct in bytes |
|
267 * nVersion : OMX spec version info |
|
268 * nPortIndex : port that this structure applies to |
|
269 * eAccuracy : Enumerated MV accuracy |
|
270 * bUnrestrictedMVs : Allow unrestricted MVs |
|
271 * bFourMV : Allow use of 4 MVs |
|
272 * sXSearchRange : Search range in horizontal direction for MVs |
|
273 * sYSearchRange : Search range in vertical direction for MVs |
|
274 */ |
|
275 typedef struct OMX_VIDEO_PARAM_MOTIONVECTORTYPE { |
|
276 OMX_U32 nSize; |
|
277 OMX_VERSIONTYPE nVersion; |
|
278 OMX_U32 nPortIndex; |
|
279 OMX_VIDEO_MOTIONVECTORTYPE eAccuracy; |
|
280 OMX_BOOL bUnrestrictedMVs; |
|
281 OMX_BOOL bFourMV; |
|
282 OMX_S32 sXSearchRange; |
|
283 OMX_S32 sYSearchRange; |
|
284 } OMX_VIDEO_PARAM_MOTIONVECTORTYPE; |
|
285 |
|
286 |
|
287 /** |
|
288 * Enumeration of possible methods to use for Intra Refresh |
|
289 */ |
|
290 typedef enum OMX_VIDEO_INTRAREFRESHTYPE { |
|
291 OMX_VIDEO_IntraRefreshCyclic, |
|
292 OMX_VIDEO_IntraRefreshAdaptive, |
|
293 OMX_VIDEO_IntraRefreshBoth, |
|
294 OMX_VIDEO_IntraRefreshKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
295 OMX_VIDEO_IntraRefreshVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
296 OMX_VIDEO_IntraRefreshMax = 0x7FFFFFFF |
|
297 } OMX_VIDEO_INTRAREFRESHTYPE; |
|
298 |
|
299 |
|
300 /** |
|
301 * Structure for configuring intra refresh mode |
|
302 * |
|
303 * STRUCT MEMBERS: |
|
304 * nSize : Size of the structure in bytes |
|
305 * nVersion : OMX specification version information |
|
306 * nPortIndex : Port that this structure applies to |
|
307 * eRefreshMode : Cyclic, Adaptive, or Both |
|
308 * nAirMBs : Number of intra macroblocks to refresh in a frame when |
|
309 * AIR is enabled |
|
310 * nAirRef : Number of times a motion marked macroblock has to be |
|
311 * intra coded |
|
312 * nCirMBs : Number of consecutive macroblocks to be coded as "intra" |
|
313 * when CIR is enabled |
|
314 */ |
|
315 typedef struct OMX_VIDEO_PARAM_INTRAREFRESHTYPE { |
|
316 OMX_U32 nSize; |
|
317 OMX_VERSIONTYPE nVersion; |
|
318 OMX_U32 nPortIndex; |
|
319 OMX_VIDEO_INTRAREFRESHTYPE eRefreshMode; |
|
320 OMX_U32 nAirMBs; |
|
321 OMX_U32 nAirRef; |
|
322 OMX_U32 nCirMBs; |
|
323 } OMX_VIDEO_PARAM_INTRAREFRESHTYPE; |
|
324 |
|
325 |
|
326 /** |
|
327 * Structure for enabling various error correction methods for video |
|
328 * compression. |
|
329 * |
|
330 * STRUCT MEMBERS: |
|
331 * nSize : Size of the structure in bytes |
|
332 * nVersion : OMX specification version information |
|
333 * nPortIndex : Port that this structure applies to |
|
334 * bEnableHEC : Enable/disable header extension codes (HEC) |
|
335 * bEnableResync : Enable/disable resynchronization markers |
|
336 * nResynchMarkerSpacing : Resynch markers interval (in bits) to be |
|
337 * applied in the stream |
|
338 * bEnableDataPartitioning : Enable/disable data partitioning |
|
339 * bEnableRVLC : Enable/disable reversible variable length |
|
340 * coding |
|
341 */ |
|
342 typedef struct OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE { |
|
343 OMX_U32 nSize; |
|
344 OMX_VERSIONTYPE nVersion; |
|
345 OMX_U32 nPortIndex; |
|
346 OMX_BOOL bEnableHEC; |
|
347 OMX_BOOL bEnableResync; |
|
348 OMX_U32 nResynchMarkerSpacing; |
|
349 OMX_BOOL bEnableDataPartitioning; |
|
350 OMX_BOOL bEnableRVLC; |
|
351 } OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE; |
|
352 |
|
353 |
|
354 /** |
|
355 * Configuration of variable block-size motion compensation (VBSMC) |
|
356 * |
|
357 * STRUCT MEMBERS: |
|
358 * nSize : Size of the structure in bytes |
|
359 * nVersion : OMX specification version information |
|
360 * nPortIndex : Port that this structure applies to |
|
361 * b16x16 : Enable inter block search 16x16 |
|
362 * b16x8 : Enable inter block search 16x8 |
|
363 * b8x16 : Enable inter block search 8x16 |
|
364 * b8x8 : Enable inter block search 8x8 |
|
365 * b8x4 : Enable inter block search 8x4 |
|
366 * b4x8 : Enable inter block search 4x8 |
|
367 * b4x4 : Enable inter block search 4x4 |
|
368 */ |
|
369 typedef struct OMX_VIDEO_PARAM_VBSMCTYPE { |
|
370 OMX_U32 nSize; |
|
371 OMX_VERSIONTYPE nVersion; |
|
372 OMX_U32 nPortIndex; |
|
373 OMX_BOOL b16x16; |
|
374 OMX_BOOL b16x8; |
|
375 OMX_BOOL b8x16; |
|
376 OMX_BOOL b8x8; |
|
377 OMX_BOOL b8x4; |
|
378 OMX_BOOL b4x8; |
|
379 OMX_BOOL b4x4; |
|
380 } OMX_VIDEO_PARAM_VBSMCTYPE; |
|
381 |
|
382 |
|
383 /** |
|
384 * H.263 profile types, each profile indicates support for various |
|
385 * performance bounds and different annexes. |
|
386 * |
|
387 * ENUMS: |
|
388 * Baseline : Baseline Profile: H.263 (V1), no optional modes |
|
389 * H320 Coding : H.320 Coding Efficiency Backward Compatibility |
|
390 * Profile: H.263+ (V2), includes annexes I, J, L.4 |
|
391 * and T |
|
392 * BackwardCompatible : Backward Compatibility Profile: H.263 (V1), |
|
393 * includes annex F |
|
394 * ISWV2 : Interactive Streaming Wireless Profile: H.263+ |
|
395 * (V2), includes annexes I, J, K and T |
|
396 * ISWV3 : Interactive Streaming Wireless Profile: H.263++ |
|
397 * (V3), includes profile 3 and annexes V and W.6.3.8 |
|
398 * HighCompression : Conversational High Compression Profile: H.263++ |
|
399 * (V3), includes profiles 1 & 2 and annexes D and U |
|
400 * Internet : Conversational Internet Profile: H.263++ (V3), |
|
401 * includes profile 5 and annex K |
|
402 * Interlace : Conversational Interlace Profile: H.263++ (V3), |
|
403 * includes profile 5 and annex W.6.3.11 |
|
404 * HighLatency : High Latency Profile: H.263++ (V3), includes |
|
405 * profile 6 and annexes O.1 and P.5 |
|
406 */ |
|
407 typedef enum OMX_VIDEO_H263PROFILETYPE { |
|
408 OMX_VIDEO_H263ProfileBaseline = 0x01, |
|
409 OMX_VIDEO_H263ProfileH320Coding = 0x02, |
|
410 OMX_VIDEO_H263ProfileBackwardCompatible = 0x04, |
|
411 OMX_VIDEO_H263ProfileISWV2 = 0x08, |
|
412 OMX_VIDEO_H263ProfileISWV3 = 0x10, |
|
413 OMX_VIDEO_H263ProfileHighCompression = 0x20, |
|
414 OMX_VIDEO_H263ProfileInternet = 0x40, |
|
415 OMX_VIDEO_H263ProfileInterlace = 0x80, |
|
416 OMX_VIDEO_H263ProfileHighLatency = 0x100, |
|
417 OMX_VIDEO_H263ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
418 OMX_VIDEO_H263ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
419 OMX_VIDEO_H263ProfileMax = 0x7FFFFFFF |
|
420 } OMX_VIDEO_H263PROFILETYPE; |
|
421 |
|
422 |
|
423 /** |
|
424 * H.263 level types, each level indicates support for various frame sizes, |
|
425 * bit rates, decoder frame rates. |
|
426 */ |
|
427 typedef enum OMX_VIDEO_H263LEVELTYPE { |
|
428 OMX_VIDEO_H263Level10 = 0x01, |
|
429 OMX_VIDEO_H263Level20 = 0x02, |
|
430 OMX_VIDEO_H263Level30 = 0x04, |
|
431 OMX_VIDEO_H263Level40 = 0x08, |
|
432 OMX_VIDEO_H263Level45 = 0x10, |
|
433 OMX_VIDEO_H263Level50 = 0x20, |
|
434 OMX_VIDEO_H263Level60 = 0x40, |
|
435 OMX_VIDEO_H263Level70 = 0x80, |
|
436 OMX_VIDEO_H263LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
437 OMX_VIDEO_H263LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
438 OMX_VIDEO_H263LevelMax = 0x7FFFFFFF |
|
439 } OMX_VIDEO_H263LEVELTYPE; |
|
440 |
|
441 |
|
442 /** |
|
443 * Specifies the picture type. These values should be OR'd to signal all |
|
444 * pictures types which are allowed. |
|
445 * |
|
446 * ENUMS: |
|
447 * Generic Picture Types: I, P and B |
|
448 * H.263 Specific Picture Types: SI and SP |
|
449 * H.264 Specific Picture Types: EI and EP |
|
450 * MPEG-4 Specific Picture Types: S |
|
451 */ |
|
452 typedef enum OMX_VIDEO_PICTURETYPE { |
|
453 OMX_VIDEO_PictureTypeI = 0x01, |
|
454 OMX_VIDEO_PictureTypeP = 0x02, |
|
455 OMX_VIDEO_PictureTypeB = 0x04, |
|
456 OMX_VIDEO_PictureTypeSI = 0x08, |
|
457 OMX_VIDEO_PictureTypeSP = 0x10, |
|
458 OMX_VIDEO_PictureTypeEI = 0x11, |
|
459 OMX_VIDEO_PictureTypeEP = 0x12, |
|
460 OMX_VIDEO_PictureTypeS = 0x14, |
|
461 OMX_VIDEO_PictureTypeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
462 OMX_VIDEO_PictureTypeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
463 OMX_VIDEO_PictureTypeMax = 0x7FFFFFFF |
|
464 } OMX_VIDEO_PICTURETYPE; |
|
465 |
|
466 |
|
467 /** |
|
468 * H.263 Params |
|
469 * |
|
470 * STRUCT MEMBERS: |
|
471 * nSize : Size of the structure in bytes |
|
472 * nVersion : OMX specification version information |
|
473 * nPortIndex : Port that this structure applies to |
|
474 * nPFrames : Number of P frames between each I frame |
|
475 * nBFrames : Number of B frames between each I frame |
|
476 * eProfile : H.263 profile(s) to use |
|
477 * eLevel : H.263 level(s) to use |
|
478 * bPLUSPTYPEAllowed : Indicating that it is allowed to use PLUSPTYPE |
|
479 * (specified in the 1998 version of H.263) to |
|
480 * indicate custom picture sizes or clock |
|
481 * frequencies |
|
482 * nAllowedPictureTypes : Specifies the picture types allowed in the |
|
483 * bitstream |
|
484 * bForceRoundingTypeToZero : value of the RTYPE bit (bit 6 of MPPTYPE) is |
|
485 * not constrained. It is recommended to change |
|
486 * the value of the RTYPE bit for each reference |
|
487 * picture in error-free communication |
|
488 * nPictureHeaderRepetition : Specifies the frequency of picture header |
|
489 * repetition |
|
490 * nGOBHeaderInterval : Specifies the interval of non-empty GOB |
|
491 * headers in units of GOBs |
|
492 */ |
|
493 typedef struct OMX_VIDEO_PARAM_H263TYPE { |
|
494 OMX_U32 nSize; |
|
495 OMX_VERSIONTYPE nVersion; |
|
496 OMX_U32 nPortIndex; |
|
497 OMX_U32 nPFrames; |
|
498 OMX_U32 nBFrames; |
|
499 OMX_VIDEO_H263PROFILETYPE eProfile; |
|
500 OMX_VIDEO_H263LEVELTYPE eLevel; |
|
501 OMX_BOOL bPLUSPTYPEAllowed; |
|
502 OMX_U32 nAllowedPictureTypes; |
|
503 OMX_BOOL bForceRoundingTypeToZero; |
|
504 OMX_U32 nPictureHeaderRepetition; |
|
505 OMX_U32 nGOBHeaderInterval; |
|
506 } OMX_VIDEO_PARAM_H263TYPE; |
|
507 |
|
508 |
|
509 /** |
|
510 * MPEG-2 profile types, each profile indicates support for various |
|
511 * performance bounds and different annexes. |
|
512 */ |
|
513 typedef enum OMX_VIDEO_MPEG2PROFILETYPE { |
|
514 OMX_VIDEO_MPEG2ProfileSimple = 0, /**< Simple Profile */ |
|
515 OMX_VIDEO_MPEG2ProfileMain, /**< Main Profile */ |
|
516 OMX_VIDEO_MPEG2Profile422, /**< 4:2:2 Profile */ |
|
517 OMX_VIDEO_MPEG2ProfileSNR, /**< SNR Profile */ |
|
518 OMX_VIDEO_MPEG2ProfileSpatial, /**< Spatial Profile */ |
|
519 OMX_VIDEO_MPEG2ProfileHigh, /**< High Profile */ |
|
520 OMX_VIDEO_MPEG2ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
521 OMX_VIDEO_MPEG2ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
522 OMX_VIDEO_MPEG2ProfileMax = 0x7FFFFFFF |
|
523 } OMX_VIDEO_MPEG2PROFILETYPE; |
|
524 |
|
525 |
|
526 /** |
|
527 * MPEG-2 level types, each level indicates support for various frame |
|
528 * sizes, bit rates, decoder frame rates. No need |
|
529 */ |
|
530 typedef enum OMX_VIDEO_MPEG2LEVELTYPE { |
|
531 OMX_VIDEO_MPEG2LevelLL = 0, /**< Low Level */ |
|
532 OMX_VIDEO_MPEG2LevelML, /**< Main Level */ |
|
533 OMX_VIDEO_MPEG2LevelH14, /**< High 1440 */ |
|
534 OMX_VIDEO_MPEG2LevelHL, /**< High Level */ |
|
535 OMX_VIDEO_MPEG2LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
536 OMX_VIDEO_MPEG2LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
537 OMX_VIDEO_MPEG2LevelMax = 0x7FFFFFFF |
|
538 } OMX_VIDEO_MPEG2LEVELTYPE; |
|
539 |
|
540 |
|
541 /** |
|
542 * MPEG-2 params |
|
543 * |
|
544 * STRUCT MEMBERS: |
|
545 * nSize : Size of the structure in bytes |
|
546 * nVersion : OMX specification version information |
|
547 * nPortIndex : Port that this structure applies to |
|
548 * nPFrames : Number of P frames between each I frame |
|
549 * nBFrames : Number of B frames between each I frame |
|
550 * eProfile : MPEG-2 profile(s) to use |
|
551 * eLevel : MPEG-2 levels(s) to use |
|
552 */ |
|
553 typedef struct OMX_VIDEO_PARAM_MPEG2TYPE { |
|
554 OMX_U32 nSize; |
|
555 OMX_VERSIONTYPE nVersion; |
|
556 OMX_U32 nPortIndex; |
|
557 OMX_U32 nPFrames; |
|
558 OMX_U32 nBFrames; |
|
559 OMX_VIDEO_MPEG2PROFILETYPE eProfile; |
|
560 OMX_VIDEO_MPEG2LEVELTYPE eLevel; |
|
561 } OMX_VIDEO_PARAM_MPEG2TYPE; |
|
562 |
|
563 |
|
564 /** |
|
565 * MPEG-4 profile types, each profile indicates support for various |
|
566 * performance bounds and different annexes. |
|
567 * |
|
568 * ENUMS: |
|
569 * - Simple Profile, Levels 1-3 |
|
570 * - Simple Scalable Profile, Levels 1-2 |
|
571 * - Core Profile, Levels 1-2 |
|
572 * - Main Profile, Levels 2-4 |
|
573 * - N-bit Profile, Level 2 |
|
574 * - Scalable Texture Profile, Level 1 |
|
575 * - Simple Face Animation Profile, Levels 1-2 |
|
576 * - Simple Face and Body Animation (FBA) Profile, Levels 1-2 |
|
577 * - Basic Animated Texture Profile, Levels 1-2 |
|
578 * - Hybrid Profile, Levels 1-2 |
|
579 * - Advanced Real Time Simple Profiles, Levels 1-4 |
|
580 * - Core Scalable Profile, Levels 1-3 |
|
581 * - Advanced Coding Efficiency Profile, Levels 1-4 |
|
582 * - Advanced Core Profile, Levels 1-2 |
|
583 * - Advanced Scalable Texture, Levels 2-3 |
|
584 */ |
|
585 typedef enum OMX_VIDEO_MPEG4PROFILETYPE { |
|
586 OMX_VIDEO_MPEG4ProfileSimple = 0x01, |
|
587 OMX_VIDEO_MPEG4ProfileSimpleScalable = 0x02, |
|
588 OMX_VIDEO_MPEG4ProfileCore = 0x04, |
|
589 OMX_VIDEO_MPEG4ProfileMain = 0x08, |
|
590 OMX_VIDEO_MPEG4ProfileNbit = 0x10, |
|
591 OMX_VIDEO_MPEG4ProfileScalableTexture = 0x20, |
|
592 OMX_VIDEO_MPEG4ProfileSimpleFace = 0x40, |
|
593 OMX_VIDEO_MPEG4ProfileSimpleFBA = 0x80, |
|
594 OMX_VIDEO_MPEG4ProfileBasicAnimated = 0x100, |
|
595 OMX_VIDEO_MPEG4ProfileHybrid = 0x200, |
|
596 OMX_VIDEO_MPEG4ProfileAdvancedRealTime = 0x400, |
|
597 OMX_VIDEO_MPEG4ProfileCoreScalable = 0x800, |
|
598 OMX_VIDEO_MPEG4ProfileAdvancedCoding = 0x1000, |
|
599 OMX_VIDEO_MPEG4ProfileAdvancedCore = 0x2000, |
|
600 OMX_VIDEO_MPEG4ProfileAdvancedScalable = 0x4000, |
|
601 OMX_VIDEO_MPEG4ProfileAdvancedSimple = 0x8000, |
|
602 OMX_VIDEO_MPEG4ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
603 OMX_VIDEO_MPEG4ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
604 OMX_VIDEO_MPEG4ProfileMax = 0x7FFFFFFF |
|
605 } OMX_VIDEO_MPEG4PROFILETYPE; |
|
606 |
|
607 |
|
608 /** |
|
609 * MPEG-4 level types, each level indicates support for various frame |
|
610 * sizes, bit rates, decoder frame rates. No need |
|
611 */ |
|
612 typedef enum OMX_VIDEO_MPEG4LEVELTYPE { |
|
613 OMX_VIDEO_MPEG4Level0 = 0x01, /**< Level 0 */ |
|
614 OMX_VIDEO_MPEG4Level0b = 0x02, /**< Level 0b */ |
|
615 OMX_VIDEO_MPEG4Level1 = 0x04, /**< Level 1 */ |
|
616 OMX_VIDEO_MPEG4Level2 = 0x08, /**< Level 2 */ |
|
617 OMX_VIDEO_MPEG4Level3 = 0x10, /**< Level 3 */ |
|
618 OMX_VIDEO_MPEG4Level4 = 0x20, /**< Level 4 */ |
|
619 OMX_VIDEO_MPEG4Level4a = 0x40, /**< Level 4a */ |
|
620 OMX_VIDEO_MPEG4Level5 = 0x80, /**< Level 5 */ |
|
621 OMX_VIDEO_MPEG4LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
622 OMX_VIDEO_MPEG4LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
623 OMX_VIDEO_MPEG4LevelMax = 0x7FFFFFFF |
|
624 } OMX_VIDEO_MPEG4LEVELTYPE; |
|
625 |
|
626 |
|
627 /** |
|
628 * MPEG-4 configuration. This structure handles configuration options |
|
629 * which are specific to MPEG4 algorithms |
|
630 * |
|
631 * STRUCT MEMBERS: |
|
632 * nSize : Size of the structure in bytes |
|
633 * nVersion : OMX specification version information |
|
634 * nPortIndex : Port that this structure applies to |
|
635 * nSliceHeaderSpacing : Number of macroblocks between slice header (H263+ |
|
636 * Annex K). Put zero if not used |
|
637 * bSVH : Enable Short Video Header mode |
|
638 * bGov : Flag to enable GOV |
|
639 * nPFrames : Number of P frames between each I frame (also called |
|
640 * GOV period) |
|
641 * nBFrames : Number of B frames between each I frame |
|
642 * nIDCVLCThreshold : Value of intra DC VLC threshold |
|
643 * bACPred : Flag to use ac prediction |
|
644 * nMaxPacketSize : Maximum size of packet in bytes. |
|
645 * nTimeIncRes : Used to pass VOP time increment resolution for MPEG4. |
|
646 * Interpreted as described in MPEG4 standard. |
|
647 * eProfile : MPEG-4 profile(s) to use. |
|
648 * eLevel : MPEG-4 level(s) to use. |
|
649 * nAllowedPictureTypes : Specifies the picture types allowed in the bitstream |
|
650 * nHeaderExtension : Specifies the number of consecutive video packet |
|
651 * headers within a VOP |
|
652 * bReversibleVLC : Specifies whether reversible variable length coding |
|
653 * is in use |
|
654 */ |
|
655 typedef struct OMX_VIDEO_PARAM_MPEG4TYPE { |
|
656 OMX_U32 nSize; |
|
657 OMX_VERSIONTYPE nVersion; |
|
658 OMX_U32 nPortIndex; |
|
659 OMX_U32 nSliceHeaderSpacing; |
|
660 OMX_BOOL bSVH; |
|
661 OMX_BOOL bGov; |
|
662 OMX_U32 nPFrames; |
|
663 OMX_U32 nBFrames; |
|
664 OMX_U32 nIDCVLCThreshold; |
|
665 OMX_BOOL bACPred; |
|
666 OMX_U32 nMaxPacketSize; |
|
667 OMX_U32 nTimeIncRes; |
|
668 OMX_VIDEO_MPEG4PROFILETYPE eProfile; |
|
669 OMX_VIDEO_MPEG4LEVELTYPE eLevel; |
|
670 OMX_U32 nAllowedPictureTypes; |
|
671 OMX_U32 nHeaderExtension; |
|
672 OMX_BOOL bReversibleVLC; |
|
673 } OMX_VIDEO_PARAM_MPEG4TYPE; |
|
674 |
|
675 |
|
676 /** |
|
677 * WMV Versions |
|
678 */ |
|
679 typedef enum OMX_VIDEO_WMVFORMATTYPE { |
|
680 OMX_VIDEO_WMVFormatUnused = 0x01, /**< Format unused or unknown */ |
|
681 OMX_VIDEO_WMVFormat7 = 0x02, /**< Windows Media Video format 7 */ |
|
682 OMX_VIDEO_WMVFormat8 = 0x04, /**< Windows Media Video format 8 */ |
|
683 OMX_VIDEO_WMVFormat9 = 0x08, /**< Windows Media Video format 9 */ |
|
684 OMX_VIDEO_WMFFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
685 OMX_VIDEO_WMFFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
686 OMX_VIDEO_WMVFormatMax = 0x7FFFFFFF |
|
687 } OMX_VIDEO_WMVFORMATTYPE; |
|
688 |
|
689 |
|
690 /** |
|
691 * WMV Params |
|
692 * |
|
693 * STRUCT MEMBERS: |
|
694 * nSize : Size of the structure in bytes |
|
695 * nVersion : OMX specification version information |
|
696 * nPortIndex : Port that this structure applies to |
|
697 * eFormat : Version of WMV stream / data |
|
698 */ |
|
699 typedef struct OMX_VIDEO_PARAM_WMVTYPE { |
|
700 OMX_U32 nSize; |
|
701 OMX_VERSIONTYPE nVersion; |
|
702 OMX_U32 nPortIndex; |
|
703 OMX_VIDEO_WMVFORMATTYPE eFormat; |
|
704 } OMX_VIDEO_PARAM_WMVTYPE; |
|
705 |
|
706 |
|
707 /** |
|
708 * Real Video Version |
|
709 */ |
|
710 typedef enum OMX_VIDEO_RVFORMATTYPE { |
|
711 OMX_VIDEO_RVFormatUnused = 0, /**< Format unused or unknown */ |
|
712 OMX_VIDEO_RVFormat8, /**< Real Video format 8 */ |
|
713 OMX_VIDEO_RVFormat9, /**< Real Video format 9 */ |
|
714 OMX_VIDEO_RVFormatG2, /**< Real Video Format G2 */ |
|
715 OMX_VIDEO_RVFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
716 OMX_VIDEO_RVFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
717 OMX_VIDEO_RVFormatMax = 0x7FFFFFFF |
|
718 } OMX_VIDEO_RVFORMATTYPE; |
|
719 |
|
720 |
|
721 /** |
|
722 * Real Video Params |
|
723 * |
|
724 * STUCT MEMBERS: |
|
725 * nSize : Size of the structure in bytes |
|
726 * nVersion : OMX specification version information |
|
727 * nPortIndex : Port that this structure applies to |
|
728 * eFormat : Version of RV stream / data |
|
729 * nBitsPerPixel : Bits per pixel coded in the frame |
|
730 * nPaddedWidth : Padded width in pixel of a video frame |
|
731 * nPaddedHeight : Padded Height in pixels of a video frame |
|
732 * nFrameRate : Rate of video in frames per second |
|
733 * nBitstreamFlags : Flags which internal information about the bitstream |
|
734 * nBitstreamVersion : Bitstream version |
|
735 * nMaxEncodeFrameSize: Max encoded frame size |
|
736 * bEnablePostFilter : Turn on/off post filter |
|
737 * bEnableTemporalInterpolation : Turn on/off temporal interpolation |
|
738 * bEnableLatencyMode : When enabled, the decoder does not display a decoded |
|
739 * frame until it has detected that no enhancement layer |
|
740 * frames or dependent B frames will be coming. This |
|
741 * detection usually occurs when a subsequent non-B |
|
742 * frame is encountered |
|
743 */ |
|
744 typedef struct OMX_VIDEO_PARAM_RVTYPE { |
|
745 OMX_U32 nSize; |
|
746 OMX_VERSIONTYPE nVersion; |
|
747 OMX_U32 nPortIndex; |
|
748 OMX_VIDEO_RVFORMATTYPE eFormat; |
|
749 OMX_U16 nBitsPerPixel; |
|
750 OMX_U16 nPaddedWidth; |
|
751 OMX_U16 nPaddedHeight; |
|
752 OMX_U32 nFrameRate; |
|
753 OMX_U32 nBitstreamFlags; |
|
754 OMX_U32 nBitstreamVersion; |
|
755 OMX_U32 nMaxEncodeFrameSize; |
|
756 OMX_BOOL bEnablePostFilter; |
|
757 OMX_BOOL bEnableTemporalInterpolation; |
|
758 OMX_BOOL bEnableLatencyMode; |
|
759 } OMX_VIDEO_PARAM_RVTYPE; |
|
760 |
|
761 |
|
762 /** |
|
763 * AVC profile types, each profile indicates support for various |
|
764 * performance bounds and different annexes. |
|
765 */ |
|
766 typedef enum OMX_VIDEO_AVCPROFILETYPE { |
|
767 OMX_VIDEO_AVCProfileBaseline = 0x01, /**< Baseline profile */ |
|
768 OMX_VIDEO_AVCProfileMain = 0x02, /**< Main profile */ |
|
769 OMX_VIDEO_AVCProfileExtended = 0x04, /**< Extended profile */ |
|
770 OMX_VIDEO_AVCProfileHigh = 0x08, /**< High profile */ |
|
771 OMX_VIDEO_AVCProfileHigh10 = 0x10, /**< High 10 profile */ |
|
772 OMX_VIDEO_AVCProfileHigh422 = 0x20, /**< High 4:2:2 profile */ |
|
773 OMX_VIDEO_AVCProfileHigh444 = 0x40, /**< High 4:4:4 profile */ |
|
774 OMX_VIDEO_AVCProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
775 OMX_VIDEO_AVCProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
776 OMX_VIDEO_AVCProfileMax = 0x7FFFFFFF |
|
777 } OMX_VIDEO_AVCPROFILETYPE; |
|
778 |
|
779 |
|
780 /** |
|
781 * AVC level types, each level indicates support for various frame sizes, |
|
782 * bit rates, decoder frame rates. No need |
|
783 */ |
|
784 typedef enum OMX_VIDEO_AVCLEVELTYPE { |
|
785 OMX_VIDEO_AVCLevel1 = 0x01, /**< Level 1 */ |
|
786 OMX_VIDEO_AVCLevel1b = 0x02, /**< Level 1b */ |
|
787 OMX_VIDEO_AVCLevel11 = 0x04, /**< Level 1.1 */ |
|
788 OMX_VIDEO_AVCLevel12 = 0x08, /**< Level 1.2 */ |
|
789 OMX_VIDEO_AVCLevel13 = 0x10, /**< Level 1.3 */ |
|
790 OMX_VIDEO_AVCLevel2 = 0x20, /**< Level 2 */ |
|
791 OMX_VIDEO_AVCLevel21 = 0x40, /**< Level 2.1 */ |
|
792 OMX_VIDEO_AVCLevel22 = 0x80, /**< Level 2.2 */ |
|
793 OMX_VIDEO_AVCLevel3 = 0x100, /**< Level 3 */ |
|
794 OMX_VIDEO_AVCLevel31 = 0x200, /**< Level 3.1 */ |
|
795 OMX_VIDEO_AVCLevel32 = 0x400, /**< Level 3.2 */ |
|
796 OMX_VIDEO_AVCLevel4 = 0x800, /**< Level 4 */ |
|
797 OMX_VIDEO_AVCLevel41 = 0x1000, /**< Level 4.1 */ |
|
798 OMX_VIDEO_AVCLevel42 = 0x2000, /**< Level 4.2 */ |
|
799 OMX_VIDEO_AVCLevel5 = 0x4000, /**< Level 5 */ |
|
800 OMX_VIDEO_AVCLevel51 = 0x8000, /**< Level 5.1 */ |
|
801 OMX_VIDEO_AVCLevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
802 OMX_VIDEO_AVCLevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
803 OMX_VIDEO_AVCLevelMax = 0x7FFFFFFF |
|
804 } OMX_VIDEO_AVCLEVELTYPE; |
|
805 |
|
806 |
|
807 /** |
|
808 * AVC loop filter modes |
|
809 * |
|
810 * OMX_VIDEO_AVCLoopFilterEnable : Enable |
|
811 * OMX_VIDEO_AVCLoopFilterDisable : Disable |
|
812 * OMX_VIDEO_AVCLoopFilterDisableSliceBoundary : Disabled on slice boundaries |
|
813 */ |
|
814 typedef enum OMX_VIDEO_AVCLOOPFILTERTYPE { |
|
815 OMX_VIDEO_AVCLoopFilterEnable = 0, |
|
816 OMX_VIDEO_AVCLoopFilterDisable, |
|
817 OMX_VIDEO_AVCLoopFilterDisableSliceBoundary, |
|
818 OMX_VIDEO_AVCLoopFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
819 OMX_VIDEO_AVCLoopFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
820 OMX_VIDEO_AVCLoopFilterMax = 0x7FFFFFFF |
|
821 } OMX_VIDEO_AVCLOOPFILTERTYPE; |
|
822 |
|
823 |
|
824 /** |
|
825 * AVC params |
|
826 * |
|
827 * STRUCT MEMBERS: |
|
828 * nSize : Size of the structure in bytes |
|
829 * nVersion : OMX specification version information |
|
830 * nPortIndex : Port that this structure applies to |
|
831 * nSliceHeaderSpacing : Number of macroblocks between slice header, put |
|
832 * zero if not used |
|
833 * nPFrames : Number of P frames between each I frame |
|
834 * nBFrames : Number of B frames between each I frame |
|
835 * bUseHadamard : Enable/disable Hadamard transform |
|
836 * nRefFrames : Max number of reference frames to use for inter |
|
837 * motion search (1-16) |
|
838 * nRefIdxTrailing : Pic param set ref frame index (index into ref |
|
839 * frame buffer of trailing frames list), B frame |
|
840 * support |
|
841 * nRefIdxForward : Pic param set ref frame index (index into ref |
|
842 * frame buffer of forward frames list), B frame |
|
843 * support |
|
844 * bEnableUEP : Enable/disable unequal error protection. This |
|
845 * is only valid of data partitioning is enabled. |
|
846 * bEnableFMO : Enable/disable flexible macroblock ordering |
|
847 * bEnableASO : Enable/disable arbitrary slice ordering |
|
848 * bEnableRS : Enable/disable sending of redundant slices |
|
849 * eProfile : AVC profile(s) to use |
|
850 * eLevel : AVC level(s) to use |
|
851 * nAllowedPictureTypes : Specifies the picture types allowed in the |
|
852 * bitstream |
|
853 * bFrameMBsOnly : specifies that every coded picture of the |
|
854 * coded video sequence is a coded frame |
|
855 * containing only frame macroblocks |
|
856 * bMBAFF : Enable/disable switching between frame and |
|
857 * field macroblocks within a picture |
|
858 * bEntropyCodingCABAC : Entropy decoding method to be applied for the |
|
859 * syntax elements for which two descriptors appear |
|
860 * in the syntax tables |
|
861 * bWeightedPPrediction : Enable/disable weighted prediction shall not |
|
862 * be applied to P and SP slices |
|
863 * nWeightedBipredicitonMode : Default weighted prediction is applied to B |
|
864 * slices |
|
865 * bconstIpred : Enable/disable intra prediction |
|
866 * bDirect8x8Inference : Specifies the method used in the derivation |
|
867 * process for luma motion vectors for B_Skip, |
|
868 * B_Direct_16x16 and B_Direct_8x8 as specified |
|
869 * in subclause 8.4.1.2 of the AVC spec |
|
870 * bDirectSpatialTemporal : Flag indicating spatial or temporal direct |
|
871 * mode used in B slice coding (related to |
|
872 * bDirect8x8Inference) . Spatial direct mode is |
|
873 * more common and should be the default. |
|
874 * nCabacInitIdx : Index used to init CABAC contexts |
|
875 * eLoopFilterMode : Enable/disable loop filter |
|
876 */ |
|
877 typedef struct OMX_VIDEO_PARAM_AVCTYPE { |
|
878 OMX_U32 nSize; |
|
879 OMX_VERSIONTYPE nVersion; |
|
880 OMX_U32 nPortIndex; |
|
881 OMX_U32 nSliceHeaderSpacing; |
|
882 OMX_U32 nPFrames; |
|
883 OMX_U32 nBFrames; |
|
884 OMX_BOOL bUseHadamard; |
|
885 OMX_U32 nRefFrames; |
|
886 OMX_U32 nRefIdx10ActiveMinus1; |
|
887 OMX_U32 nRefIdx11ActiveMinus1; |
|
888 OMX_BOOL bEnableUEP; |
|
889 OMX_BOOL bEnableFMO; |
|
890 OMX_BOOL bEnableASO; |
|
891 OMX_BOOL bEnableRS; |
|
892 OMX_VIDEO_AVCPROFILETYPE eProfile; |
|
893 OMX_VIDEO_AVCLEVELTYPE eLevel; |
|
894 OMX_U32 nAllowedPictureTypes; |
|
895 OMX_BOOL bFrameMBsOnly; |
|
896 OMX_BOOL bMBAFF; |
|
897 OMX_BOOL bEntropyCodingCABAC; |
|
898 OMX_BOOL bWeightedPPrediction; |
|
899 OMX_U32 nWeightedBipredicitonMode; |
|
900 OMX_BOOL bconstIpred ; |
|
901 OMX_BOOL bDirect8x8Inference; |
|
902 OMX_BOOL bDirectSpatialTemporal; |
|
903 OMX_U32 nCabacInitIdc; |
|
904 OMX_VIDEO_AVCLOOPFILTERTYPE eLoopFilterMode; |
|
905 } OMX_VIDEO_PARAM_AVCTYPE; |
|
906 |
|
907 typedef struct OMX_VIDEO_PARAM_PROFILELEVELTYPE { |
|
908 OMX_U32 nSize; |
|
909 OMX_VERSIONTYPE nVersion; |
|
910 OMX_U32 nPortIndex; |
|
911 OMX_U32 eProfile; /**< type is OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263PROFILETYPE, |
|
912 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */ |
|
913 OMX_U32 eLevel; /**< type is OMX_VIDEO_AVCLEVELTYPE, OMX_VIDEO_H263LEVELTYPE, |
|
914 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */ |
|
915 OMX_U32 nProfileIndex; /**< Used to query for individual profile support information, |
|
916 This parameter is valid only for |
|
917 OMX_IndexParamVideoProfileLevelQuerySupported index, |
|
918 For all other indices this parameter is to be ignored. */ |
|
919 } OMX_VIDEO_PARAM_PROFILELEVELTYPE; |
|
920 |
|
921 /** |
|
922 * Structure for dynamically configuring bitrate mode of a codec. |
|
923 * |
|
924 * STRUCT MEMBERS: |
|
925 * nSize : Size of the struct in bytes |
|
926 * nVersion : OMX spec version info |
|
927 * nPortIndex : Port that this struct applies to |
|
928 * nEncodeBitrate : Target average bitrate to be generated in bps |
|
929 */ |
|
930 typedef struct OMX_VIDEO_CONFIG_BITRATETYPE { |
|
931 OMX_U32 nSize; |
|
932 OMX_VERSIONTYPE nVersion; |
|
933 OMX_U32 nPortIndex; |
|
934 OMX_U32 nEncodeBitrate; |
|
935 } OMX_VIDEO_CONFIG_BITRATETYPE; |
|
936 |
|
937 /** |
|
938 * Defines Encoder Frame Rate setting |
|
939 * |
|
940 * STRUCT MEMBERS: |
|
941 * nSize : Size of the structure in bytes |
|
942 * nVersion : OMX specification version information |
|
943 * nPortIndex : Port that this structure applies to |
|
944 * xEncodeFramerate : Encoding framerate represented in Q16 format |
|
945 */ |
|
946 typedef struct OMX_CONFIG_FRAMERATETYPE { |
|
947 OMX_U32 nSize; |
|
948 OMX_VERSIONTYPE nVersion; |
|
949 OMX_U32 nPortIndex; |
|
950 OMX_U32 xEncodeFramerate; /* Q16 format */ |
|
951 } OMX_CONFIG_FRAMERATETYPE; |
|
952 |
|
953 typedef struct OMX_CONFIG_INTRAREFRESHVOPTYPE { |
|
954 OMX_U32 nSize; |
|
955 OMX_VERSIONTYPE nVersion; |
|
956 OMX_U32 nPortIndex; |
|
957 OMX_BOOL IntraRefreshVOP; |
|
958 } OMX_CONFIG_INTRAREFRESHVOPTYPE; |
|
959 |
|
960 typedef struct OMX_CONFIG_MACROBLOCKERRORMAPTYPE { |
|
961 OMX_U32 nSize; |
|
962 OMX_VERSIONTYPE nVersion; |
|
963 OMX_U32 nPortIndex; |
|
964 OMX_U32 nErrMapSize; /* Size of the Error Map in bytes */ |
|
965 OMX_U8 ErrMap[1]; /* Error map hint */ |
|
966 } OMX_CONFIG_MACROBLOCKERRORMAPTYPE; |
|
967 |
|
968 typedef struct OMX_CONFIG_MBERRORREPORTINGTYPE { |
|
969 OMX_U32 nSize; |
|
970 OMX_VERSIONTYPE nVersion; |
|
971 OMX_U32 nPortIndex; |
|
972 OMX_BOOL bEnabled; |
|
973 } OMX_CONFIG_MBERRORREPORTINGTYPE; |
|
974 |
|
975 typedef struct OMX_PARAM_MACROBLOCKSTYPE { |
|
976 OMX_U32 nSize; |
|
977 OMX_VERSIONTYPE nVersion; |
|
978 OMX_U32 nPortIndex; |
|
979 OMX_U32 nMacroblocks; |
|
980 } OMX_PARAM_MACROBLOCKSTYPE; |
|
981 |
|
982 /** |
|
983 * AVC Slice Mode modes |
|
984 * |
|
985 * OMX_VIDEO_SLICEMODE_AVCDefault : Normal frame encoding, one slice per frame |
|
986 * OMX_VIDEO_SLICEMODE_AVCMBSlice : NAL mode, number of MBs per frame |
|
987 * OMX_VIDEO_SLICEMODE_AVCByteSlice : NAL mode, number of bytes per frame |
|
988 */ |
|
989 typedef enum OMX_VIDEO_AVCSLICEMODETYPE { |
|
990 OMX_VIDEO_SLICEMODE_AVCDefault = 0, |
|
991 OMX_VIDEO_SLICEMODE_AVCMBSlice, |
|
992 OMX_VIDEO_SLICEMODE_AVCByteSlice, |
|
993 OMX_VIDEO_SLICEMODE_AVCKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ |
|
994 OMX_VIDEO_SLICEMODE_AVCVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */ |
|
995 OMX_VIDEO_SLICEMODE_AVCLevelMax = 0x7FFFFFFF |
|
996 } OMX_VIDEO_AVCSLICEMODETYPE; |
|
997 |
|
998 /** |
|
999 * AVC FMO Slice Mode Params |
|
1000 * |
|
1001 * STRUCT MEMBERS: |
|
1002 * nSize : Size of the structure in bytes |
|
1003 * nVersion : OMX specification version information |
|
1004 * nPortIndex : Port that this structure applies to |
|
1005 * nNumSliceGroups : Specifies the number of slice groups |
|
1006 * nSliceGroupMapType : Specifies the type of slice groups |
|
1007 * eSliceMode : Specifies the type of slice |
|
1008 */ |
|
1009 typedef struct OMX_VIDEO_PARAM_AVCSLICEFMO { |
|
1010 OMX_U32 nSize; |
|
1011 OMX_VERSIONTYPE nVersion; |
|
1012 OMX_U32 nPortIndex; |
|
1013 OMX_U8 nNumSliceGroups; |
|
1014 OMX_U8 nSliceGroupMapType; |
|
1015 OMX_VIDEO_AVCSLICEMODETYPE eSliceMode; |
|
1016 } OMX_VIDEO_PARAM_AVCSLICEFMO; |
|
1017 |
|
1018 /** |
|
1019 * AVC IDR Period Configs |
|
1020 * |
|
1021 * STRUCT MEMBERS: |
|
1022 * nSize : Size of the structure in bytes |
|
1023 * nVersion : OMX specification version information |
|
1024 * nPortIndex : Port that this structure applies to |
|
1025 * nIDRPeriod : Specifies periodicity of IDR frames |
|
1026 * nPFrames : Specifies internal of coding Intra frames |
|
1027 */ |
|
1028 typedef struct OMX_VIDEO_CONFIG_AVCINTRAPERIOD { |
|
1029 OMX_U32 nSize; |
|
1030 OMX_VERSIONTYPE nVersion; |
|
1031 OMX_U32 nPortIndex; |
|
1032 OMX_U32 nIDRPeriod; |
|
1033 OMX_U32 nPFrames; |
|
1034 } OMX_VIDEO_CONFIG_AVCINTRAPERIOD; |
|
1035 |
|
1036 /** |
|
1037 * AVC NAL Size Configs |
|
1038 * |
|
1039 * STRUCT MEMBERS: |
|
1040 * nSize : Size of the structure in bytes |
|
1041 * nVersion : OMX specification version information |
|
1042 * nPortIndex : Port that this structure applies to |
|
1043 * nNaluBytes : Specifies the NAL unit size |
|
1044 */ |
|
1045 typedef struct OMX_VIDEO_CONFIG_NALSIZE { |
|
1046 OMX_U32 nSize; |
|
1047 OMX_VERSIONTYPE nVersion; |
|
1048 OMX_U32 nPortIndex; |
|
1049 OMX_U32 nNaluBytes; |
|
1050 } OMX_VIDEO_CONFIG_NALSIZE; |
|
1051 |
|
1052 /** @} */ |
|
1053 |
|
1054 #ifdef __cplusplus |
|
1055 } |
|
1056 #endif /* __cplusplus */ |
|
1057 |
|
1058 #endif |
|
1059 /* File EOF */ |
|
1060 |