omxil: Add a broadcom/raspberry pi specific OMX header
[vlc.git] / modules / codec / omxil / OMX_Broadcom.h
1 /*
2 Copyright (c) 2012, Broadcom Europe Ltd
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7     * Redistributions of source code must retain the above copyright
8       notice, this list of conditions and the following disclaimer.
9     * Redistributions in binary form must reproduce the above copyright
10       notice, this list of conditions and the following disclaimer in the
11       documentation and/or other materials provided with the distribution.
12     * Neither the name of the copyright holder nor the
13       names of its contributors may be used to endorse or promote products
14       derived from this software without specific prior written permission.
15
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
20 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 // OpenMAX IL - Broadcom specific types
29
30 #ifndef OMX_Broadcom_h
31 #define OMX_Broadcom_h
32
33 #include "OMX_Component.h"
34
35 // for use in buffer headers - marks the contained data
36 // as being a codec header
37 #define OMX_BUFFERFLAG_TIME_UNKNOWN 0x00000100
38
39 //for use in buffer headers - marks the buffer as being the
40 //snapshot preview image from a still capture.
41 //Mainly to be used with the DisplayFunction callback from camera.
42 #define OMX_BUFFERFLAG_CAPTURE_PREVIEW 0x00000200
43
44 /* Mark the end of a NAL unit produced by a video encoder.
45  */
46 #define OMX_BUFFERFLAG_ENDOFNAL    0x00000400
47
48 /* Marks pBuffer in OMX_BUFFERHEADERTYPE as containing a fragment list instead of the actual buffer
49  */
50 #define OMX_BUFFERFLAG_FRAGMENTLIST 0x00000800
51
52 /* Marks the start of a new sequence of data following any kind of seek operation.
53  */
54 #define OMX_BUFFERFLAG_DISCONTINUITY 0x00001000
55
56 /** Codec side information Flag:
57 * OMX_BUFFERFLAG_CODECSIDEINFO is an optional flag that is set by an
58 * output port when all bytes in the buffer form part or all of a set of
59 * codec specific side information. For example, distortion information
60 * estimated by H.264 encoder can be sent using this flag to signal
61 * the decoder quality
62 */
63 #define OMX_BUFFERFLAG_CODECSIDEINFO 0x00002000
64
65 /**
66  * Macros to convert to <code>OMX_TICKS</code> from a signed 64 bit value and
67  * vice-versa. These macros don't actually do anything unless <code>OMX_TICKS</code>
68  * is defined as a two-part structure (instead of a native signed 64-bit type).
69  **/
70 #ifndef OMX_SKIP64BIT
71    #define omx_ticks_from_s64(s) (s)
72    #define omx_ticks_to_s64(t) (t)
73 #else
74    static inline OMX_TICKS omx_ticks_from_s64(signed long long s) { OMX_TICKS t; t.nLowPart = (OMX_U32)s; t.nHighPart = (OMX_U32)(s>>32); return t; }
75    #define omx_ticks_to_s64(t) ((t).nLowPart | ((uint64_t)((t).nHighPart) << 32))
76 #endif /* OMX_SKIP64BIT */
77
78 /* Buffer fragment descriptor */
79 typedef struct OMX_BUFFERFRAGMENTTYPE {
80    OMX_PTR pBuffer; /**< Pointer to actual block of memory that is acting as the fragment buffer */
81    OMX_U32 nLen;    /**< number of bytes in the buffer */
82 } OMX_BUFFERFRAGMENTTYPE;
83
84 /* OMX_IndexParamBrcmEnableIJGTableScaling: JPEG Quality Table Setting. */
85 typedef struct OMX_PARAM_IJGSCALINGTYPE {
86    OMX_U32 nSize;
87    OMX_VERSIONTYPE nVersion;
88    OMX_U32 nPortIndex;
89    OMX_BOOL bEnabled;
90 } OMX_PARAM_IJGSCALINGTYPE;
91 /*
92 The boolean \code{bEnabled} value determines whether the component uses
93 the standard IJG quality tables when encoding images.
94 */
95
96
97 /* OMX_IndexConfigTimeInvalidStartTime: Invalid Start Times */
98 /*
99 This allows clock clients to supply a start time notification to the
100 clock whilst indicating that this time is invalid.
101 */
102
103 /* OMX_IndexParamBrcmMaxFrameSkips: Frame timestamp jumps */
104 /*
105 This number represents the number of times a jump in frame timestamps
106 has been observed that is greater than expected.
107 */
108
109 /* OMX_IndexConfigAsynchronousFailureURI: Asynchronous Failure Filename */
110 /*
111 This allows the client to query for the filename that cause an asynchronous
112 output error.
113 */
114
115 /* OMX_IndexParamAsynchronousOutput: Asynchronous Output */
116 /*
117 The allows the client to specify to a component that is writing files
118 that this writing may happen asynchronously, including opening and closing
119 of files.
120 */
121
122 /* OMX_IndexConfigClockAdjustment: Clock Adjustment */
123 /*
124 This allows the client to read from the clock the total time
125 adjustment made to the clock whilst running by the reference clock.
126 If the reference clock sends a time that causes the media time to jump
127 this difference is added to the total, which can be reported via this
128 index.  When the stream restarts by setting the clock state to
129 \code{OMX_TIME_ClockStateRunning} or
130 \code{OMX_TIME_ClockStateWaitingForStartTime} this adjustment total is
131 set to zero.
132 */
133
134 /* OMX_IndexParamBrcmDataUnit: Data Unit */
135 /*
136 The data unit is an indication to components connected to this
137 component of the type of data delivery available.
138 \code{OMX_DataUnitCodedPicture} indicates that we are able to give
139 framing information, using the \code{OMX_BUFFERFLAG_ENDOFFRAME} flag to
140 indicate that the data contained finishes a complete
141 frame. \code{OMX_DataUnitArbitraryStreamSection} indicates that no
142 end-of-frame markers will be present, and the decoder should perform
143 the steps necessary to decode the stream. The other enum values are
144 not used.
145 */
146
147 /* OMX_IndexConfigPresentationOffset: Presentation Offset */
148 /*
149 The value of \code{nTimestamp} is added to the offset requested for
150 each new input frame. Takes effect for all new input frames, and has
151 no effect on the offset used for currently-queued frames. A positive
152 value will make the requested port earlier relative to other streams,
153 a negative value will make the requested port later relative to other
154 streams.
155 */
156
157 /* OMX_IndexConfigSingleStep: Single Step */
158 /*
159 When setting this config on a paused clock, where the \code{nU32}
160 value is non-zero and \code{nPortIndex} is OMX_ALL, the media clock
161 will advance through the next \code{nU32} next requested media
162 times. A paused clock is in running state but has a time scale of
163 0. This will trigger the display of some video frames, so allowing
164 single-stepping functionality. This config can be set multiple times,
165 and will buffer up stepping requests until we have media requests to
166 fulfil, or the clock is stopped or un-paused.
167
168 This config can also be used on some video output ports and, if
169 \code{nU32} is non-zero, requests that the output port forwards the
170 next \code{nU32} frames appending an EOS marker on the last frame, and
171 then ceases to forward data on this port.  If \code{nU32} is zero, any
172 previous request to forward a limited number of frames is cancelled
173 and the default behaviour of this port will resume.
174 */
175
176 /* OMX_IndexParamCameraCamplusId: Camera Subsystem Identification */
177 /*
178 This parameter allows the configuration of the identifier to be used
179 to initialise the Broadcom Camplus subsystem that sits beneath the
180 camera component. If only one instance of the camera component is
181 used, the default value can be used. If more than one instance is
182 required, they must each have their own unique values for this
183 parameter. It is also used to tie the component to the image pool
184 created with \code{OMX_Set upCamPools}.
185 */
186
187 /* OMX_IndexConfigAudioRenderingLatency: Audio Rendering Latency */
188 /*
189 This config allows the client to query the current latency of audio
190 rendering.  The latency is returned as the number of samples that
191 an audio rendering component has received but have not been played.
192 */
193
194 /* OMX_IndexConfigBrcmPoolMemAllocSize: Pool memory usage values */
195 /*
196 This config allows the client to query how much memory is being used by
197 the component for any image pools. 
198 */
199
200 /* OMX_IndexConfigDisplayRegion: Display Region */
201 typedef enum OMX_DISPLAYTRANSFORMTYPE{
202    OMX_DISPLAY_ROT0 = 0,
203    OMX_DISPLAY_MIRROR_ROT0 = 1,
204    OMX_DISPLAY_MIRROR_ROT180 = 2,
205    OMX_DISPLAY_ROT180 = 3,
206    OMX_DISPLAY_MIRROR_ROT90 = 4,
207    OMX_DISPLAY_ROT270 = 5,
208    OMX_DISPLAY_ROT90 = 6,
209    OMX_DISPLAY_MIRROR_ROT270 = 7,
210    OMX_DISPLAY_DUMMY = 0x7FFFFFFF
211 } OMX_DISPLAYTRANSFORMTYPE;
212
213 typedef struct OMX_DISPLAYRECTTYPE {
214    OMX_S16 x_offset;
215    OMX_S16 y_offset;
216    OMX_S16 width;
217    OMX_S16 height;
218 } OMX_DISPLAYRECTTYPE;
219
220 typedef enum OMX_DISPLAYMODETYPE {
221    OMX_DISPLAY_MODE_FILL = 0,
222    OMX_DISPLAY_MODE_LETTERBOX = 1,
223    OMX_DISPLAY_MODE_DUMMY = 0x7FFFFFFF
224 } OMX_DISPLAYMODETYPE;
225
226 typedef enum OMX_DISPLAYSETTYPE {
227    OMX_DISPLAY_SET_NONE = 0,
228    OMX_DISPLAY_SET_NUM = 1,
229    OMX_DISPLAY_SET_FULLSCREEN = 2,
230    OMX_DISPLAY_SET_TRANSFORM = 4,
231    OMX_DISPLAY_SET_DEST_RECT = 8,
232    OMX_DISPLAY_SET_SRC_RECT = 0x10,
233    OMX_DISPLAY_SET_MODE = 0x20,
234    OMX_DISPLAY_SET_PIXEL = 0x40,
235    OMX_DISPLAY_SET_NOASPECT = 0x80,
236    OMX_DISPLAY_SET_LAYER = 0x100,
237    OMX_DISPLAY_SET_COPYPROTECT = 0x200,
238    OMX_DISPLAY_SET_ALPHA = 0x400,
239    OMX_DISPLAY_SET_DUMMY = 0x7FFFFFFF
240 } OMX_DISPLAYSETTYPE;
241
242 typedef struct OMX_CONFIG_DISPLAYREGIONTYPE {
243    OMX_U32 nSize;
244    OMX_VERSIONTYPE nVersion;
245    OMX_U32 nPortIndex;
246    OMX_DISPLAYSETTYPE set;
247    OMX_U32 num;
248    OMX_BOOL fullscreen;
249    OMX_DISPLAYTRANSFORMTYPE transform;
250    OMX_DISPLAYRECTTYPE dest_rect;
251    OMX_DISPLAYRECTTYPE src_rect;
252    OMX_BOOL noaspect;
253    OMX_DISPLAYMODETYPE mode;
254    OMX_U32 pixel_x;
255    OMX_U32 pixel_y;
256    OMX_S32 layer;
257    OMX_BOOL copyprotect_required;
258    OMX_U32 alpha;
259    OMX_U32 wfc_context_width;
260    OMX_U32 wfc_context_height;
261 } OMX_CONFIG_DISPLAYREGIONTYPE;
262 /*
263 This config sets the output display device, as well as the region used
264 on the output display, any display transformation, and some flags to
265 indicate how to scale the image.
266
267 The structure uses a bitfield, \code{set}, to indicate which fields are set
268 and should be used. All other fields will maintain their current
269 value.
270
271 \code{num} describes the display output device, with 0 typically being
272 a directly connected LCD display.
273
274 \code{fullscreen} indicates that we are using the full device screen
275 area, rather than a window of the display.  If fullscreen is false,
276 then dest_rect is used to specify a region of the display to use.
277
278 \code{transform} indicates any rotation or flipping used to map frames
279 onto the natural display orientation.
280
281 The \code{src_rect} indicates which area of the frame to display. If
282 all values are zero, the whole frame will be used.
283
284 The \code{noaspect} flag, if set, indicates that any display scaling
285 should disregard the aspect ratio of the frame region being displayed.
286
287 \code{mode} indicates how the image should be scaled to fit the
288 display. \code{OMX_DISPLAY_MODE_FILL} indicates that the image should
289 fill the screen by potentially cropping the frames.  Setting
290 \code{mode} to \code{OMX_DISPLAY_MODE_LETTERBOX} indicates that all
291 the source region should be displayed and black bars added if
292 necessary.
293
294 The \code{pixel_x} and \code{pixel_y} values, if non-zero, are used to
295 describe the size of a source pixel. If values are zero, then pixels
296 default to being square.
297
298 Set the \code{layer} that the image will appear on with the
299 \code{layer} field.
300 */
301
302
303
304 /* OMX_IndexParamSource: Source Image Configuration */
305 typedef enum OMX_SOURCETYPE {
306    OMX_SOURCE_WHITE = 0,    // all white images
307    OMX_SOURCE_BLACK = 1,    // all black images
308    OMX_SOURCE_DIAGONAL = 2, // greyscale diagonal stripes
309    OMX_SOURCE_NOISE = 3,    // random pixel values
310    OMX_SOURCE_RANDOM = 4,   // a shaded random pattern of colours
311    OMX_SOURCE_COLOUR = 5,   // a solid colour determined by nParam
312    OMX_SOURCE_BLOCKS = 6,   // random coloured blocks of 16x16 size
313    OMX_SOURCE_SWIRLY,       // a swirly pattern used for encode testing
314    OMX_SOURCE_DUMMY = 0x7FFFFFFF
315 } OMX_SOURCETYPE;
316
317 typedef struct OMX_PARAM_SOURCETYPE {
318    OMX_U32 nSize;
319    OMX_VERSIONTYPE nVersion;
320    OMX_U32 nPortIndex;
321    OMX_SOURCETYPE eType;
322    OMX_U32 nParam;
323    OMX_U32 nFrameCount;
324    OMX_U32 xFrameRate;
325 } OMX_PARAM_SOURCETYPE;
326 /*
327 The source type determines the kind of image that is produced. Not all
328 combinations of source type and image type are supported.  The
329 \code{OMX_SOURCE_SWIRLY} setting can only be used with YUV420 packed
330 planar image formats.  When producing RGB565 image format, the
331 \code{OMX_SOURCE_DIAGONAL} and \code{OMX_SOURCE_RANDOM} modes are
332 treated as \code{OMX_SOURCE_NOISE}.
333
334 The \code{nParam} field is used to specify the colour for the source
335 colour mode, and the offset of the diagonal pattern for diagonal mode.
336 For the blocks mode, \code{nParam} is used as the seed for the random
337 colour generator.
338
339 The \code{nFrameCount} parameter determines how many frames to send.
340 If it is zero, then frames are sent continuously. For any other value,
341 it counts down until it has sent that many frames, and then stops,
342 sending out an EOS. The \code{xFrameRate} setting is used to determine
343 the timestamp for each frame produced, or can be set to zero if
344 timestamps should all remain at zero.
345 */
346
347 /* OMX_IndexParamSourceSeed: Source Random Seed */
348 typedef struct OMX_PARAM_SOURCESEEDTYPE {
349    OMX_U32 nSize;
350    OMX_VERSIONTYPE nVersion;
351    OMX_U32 nPortIndex;
352    OMX_U16 nData[16];
353 } OMX_PARAM_SOURCESEEDTYPE;
354 /*
355 This structure sets the current state of the random number generator
356 used for \code{OMX_SOURCE_RANDOM} source type, allowing repeatable
357 random image creation.
358 */
359
360 /* OMX_IndexParamResize: Resize Control */
361 typedef enum OMX_RESIZEMODETYPE {
362    OMX_RESIZE_NONE,
363    OMX_RESIZE_CROP,
364    OMX_RESIZE_BOX,
365    OMX_RESIZE_BYTES,
366    OMX_RESIZE_DUMMY = 0x7FFFFFFF
367 } OMX_RESIZEMODETYPE;
368
369 typedef struct OMX_PARAM_RESIZETYPE {
370    OMX_U32 nSize;
371    OMX_VERSIONTYPE nVersion;
372    OMX_U32 nPortIndex;
373    OMX_RESIZEMODETYPE eMode;
374    OMX_U32 nMaxWidth;
375    OMX_U32 nMaxHeight;
376    OMX_U32 nMaxBytes;
377    OMX_BOOL bPreserveAspectRatio;
378    OMX_BOOL bAllowUpscaling;
379 } OMX_PARAM_RESIZETYPE;
380 /*
381 The mode determines the kind of resize. \code{OMX_RESIZE_BOX} allow
382 the \code{nMaxWidth} and \code{nMaxHeight} to set a bounding box into
383 which the output must fit. \code{OMX_RESIZE_BYTES} allows
384 \code{nMaxBytes} to set the maximum number of bytes into which the
385 full output frame must fit.  Two flags aid the setting of the output
386 size. \code{bPreseveAspectRatio} sets whether the resize should
387 preserve the aspect ratio of the incoming
388 image. \code{bAllowUpscaling} sets whether the resize is allowed to
389 increase the size of the output image compared to the size of the
390 input image.
391 */
392
393 typedef struct OMX_PARAM_TESTINTERFACETYPE {
394    OMX_U32 nSize;
395    OMX_VERSIONTYPE nVersion;
396    OMX_BOOL bTest;
397    OMX_BOOL bSetExtra;
398    OMX_U32 nExtra;
399    OMX_BOOL bSetError;
400    OMX_BOOL stateError[2];
401 } OMX_PARAM_TESTINTERFACETYPE;
402
403 /* OMX_IndexConfigVisualisation: Visualisation Mode */
404 typedef struct OMX_CONFIG_VISUALISATIONTYPE {
405    OMX_U32 nSize;
406    OMX_VERSIONTYPE nVersion;
407    OMX_U32 nPortIndex;
408    OMX_U8 name[16];
409    OMX_U8 property[64];
410 } OMX_CONFIG_VISUALISATIONTYPE;
411
412 /*
413 \code{name} is a string of characters specifying the type of
414 visualization. The component appends \code{"_vis.vll"} to the name
415 provided, and attempts to load a visualisation library contained in
416 this VLL.  \code{property} contains configuration parameters and
417 values, which is interpreted by the visualisation library. Typically
418 all visualisations will accept a property string containing
419 \code{'mode=<number>'}, where \code{<number>} may be a random 32 bit
420 integer in decimal format. If provided, this may select a random mode
421 from that visualisation library.
422 */
423
424 /*
425 This parameter is used when creating proprietary communication with
426 the display component, and provides the display function for passing
427 images to be displayed, together with a function used to flush all
428 pending image updates and release all images.
429 */
430
431 /* OMX_IndexConfigBrcmAudioDestination: Audio Destination */
432 typedef struct OMX_CONFIG_BRCMAUDIODESTINATIONTYPE {
433    OMX_U32 nSize;
434    OMX_VERSIONTYPE nVersion;
435    OMX_U8 sName[16];
436 } OMX_CONFIG_BRCMAUDIODESTINATIONTYPE;
437 /*
438 This config sets the platform-specific audio destination or output
439 device for audio sink components (e.g. audio_render).
440
441 \code{sName} describes the audio destination, with \code{"local"}
442 typically being directly connected to headphones.
443 */
444
445 /* OMX_IndexConfigBrcmAudioSource: Audio Source */
446 typedef struct OMX_CONFIG_BRCMAUDIOSOURCETYPE {
447    OMX_U32 nSize;
448    OMX_VERSIONTYPE nVersion;
449    OMX_U8 sName[16];
450 } OMX_CONFIG_BRCMAUDIOSOURCETYPE;
451 /*
452 This config sets the platform-specific audio source or input device
453 for audio source components (e.g. audio_capture).
454
455 \code{sName} describes the audio source, with \code{"local"}
456 typically being directly connected to microphone.
457 */
458
459 /* OMX_IndexConfigBrcmAudioDownmixCoefficients: Audio Downmix Coefficients */
460 typedef struct OMX_CONFIG_BRCMAUDIODOWNMIXCOEFFICIENTS {
461    OMX_U32 nSize;
462    OMX_VERSIONTYPE nVersion;
463    OMX_U32 nPortIndex;
464    OMX_U32 coeff[16];
465 } OMX_CONFIG_BRCMAUDIODOWNMIXCOEFFICIENTS;
466 /*
467 This config sets the platform-specific audio downmixing coefficients for the 
468 audio mixer component. The coefficients are 16.16 fixed point.
469 The even coefficients contribute to the left channel. 
470 The odd coefficients contribute to the right channel. 
471 L' = coeff[0] * sample[N] + coeff[2] * sample[N+1] + coeff[4] * sample[N+2] + coeff[6] * sample[N+3] 
472    + coeff[8] * sample[N+4] + coeff[10] * sample[N+5] + coeff[12] * sample[N+6] + coeff[14] * sample[N+7]
473 R' = coeff[1] * sample[N] + coeff[3] * sample[N+1] + coeff[5] * sample[N+2] + coeff[7] * sample[N+3] 
474    + coeff[9] * sample[N+4] + coeff[11] * sample[N+5] + coeff[13] * sample[N+6] + coeff[15] * sample[N+7]
475
476 \code{coeff} describes the downmixing coefficients
477 */
478
479 /* OMX_IndexConfigPlayMode: Play Mode */
480 typedef enum OMX_PLAYMODETYPE {
481    OMX_PLAYMODE_NORMAL,
482    OMX_PLAYMODE_FF,
483    OMX_PLAYMODE_REW,
484    OMX_PLAYMODE_DUMMY = 0x7FFFFFFF
485 } OMX_PLAYMODETYPE;
486
487 typedef struct OMX_CONFIG_PLAYMODETYPE {
488    OMX_U32 nSize;
489    OMX_VERSIONTYPE nVersion;
490    OMX_PLAYMODETYPE eMode;
491 } OMX_CONFIG_PLAYMODETYPE;
492 /*
493 The playmode affects which frames are extracted from the media file
494 and passed on the output ports. \code{OMX_PLAYMODE_NORMAL} will
495 extract all frames, \code{OMX_PLAYMODE_FF} extracts only IDR frames
496 when video is present, or only occasional packets of audio if no video
497 is present. \code{OMX_PLAYMODE_REW} is similar to
498 \code{OMX_PLAYMODE_FF} but extracts packets in reverse time
499 order.
500 */
501
502 typedef enum OMX_DELIVERYFORMATTYPE {
503    OMX_DELIVERYFORMAT_STREAM,         // no framing information is known
504    OMX_DELIVERYFORMAT_SINGLE_PACKET,  // packetised, at most one frame per buffer
505    OMX_DELIVERYFORMAT_DUMMY = 0x7FFFFFFF
506 } OMX_DELIVERYFORMATTYPE;
507
508 typedef struct OMX_PARAM_DELIVERYFORMATTYPE {
509    OMX_U32 nSize;
510    OMX_VERSIONTYPE nVersion;
511    OMX_U32 nPortIndex;
512    OMX_DELIVERYFORMATTYPE eFormat;
513 } OMX_PARAM_DELIVERYFORMATTYPE;
514
515 /* OMX_IndexParamCodecConfig: Codec Configuration */
516
517 typedef struct OMX_PARAM_CODECCONFIGTYPE {
518    OMX_U32 nSize;
519    OMX_VERSIONTYPE nVersion;
520    OMX_U32 nPortIndex;
521    OMX_U32 bCodecConfigIsComplete;
522    OMX_U8 nData[1];
523 } OMX_PARAM_CODECCONFIGTYPE;
524
525 /*
526 This parameter contains opaque data in a format specified by Broadcom
527 and allows out-of-band information such as cropping rectangles, aspect
528 ratio information, codec-specific header bytes, and other essential
529 information to be passed between connected components.
530
531 \code{bCodecConfigIsCompete} specifies if the codec config is fully
532 contained in here and there is no need to wait for OMX_BUFFERFLAG_CODECCONFIG
533 buffers
534 */
535
536 typedef struct OMX_PARAM_STILLSFUNCTIONTYPE {
537    OMX_U32 nSize;
538    OMX_VERSIONTYPE nVersion;
539    OMX_BOOL bBuffer;
540    OMX_PTR (*pOpenFunc)(void);
541    OMX_PTR (*pCloseFunc)(void);
542    OMX_PTR (*pReadFunc)(void);
543    OMX_PTR (*pSeekFunc)(void);
544    OMX_PTR (*pWriteFunc)(void);
545 } OMX_PARAM_STILLSFUNCTIONTYPE;
546
547 typedef void* OMX_BUFFERADDRESSHANDLETYPE;
548
549 typedef struct OMX_PARAM_BUFFERADDRESSTYPE {
550    OMX_U32 nSize;
551    OMX_VERSIONTYPE nVersion;
552    OMX_U32 nPortIndex;
553    OMX_U32 nAllocLen;
554    OMX_BUFFERADDRESSHANDLETYPE handle;
555 } OMX_PARAM_BUFFERADDRESSTYPE;
556
557 typedef struct OMX_PARAM_TUNNELSETUPTYPE {
558    OMX_U32 nSize;
559    OMX_VERSIONTYPE nVersion;
560    OMX_U32 nPortIndex;
561    OMX_TUNNELSETUPTYPE sSetup;
562 } OMX_PARAM_TUNNELSETUPTYPE;
563
564 /* OMX_IndexParamBrcmPortEGL: Used for querying whether a port is an EGL port or not. */
565 typedef struct OMX_PARAM_BRCMPORTEGLTYPE {
566    OMX_U32 nSize;
567    OMX_VERSIONTYPE nVersion;
568    OMX_U32 nPortIndex;
569    OMX_BOOL bPortIsEGL;
570 } OMX_PARAM_BRCMPORTEGLTYPE;
571 /*
572 */
573
574 /* OMX_IndexConfigCommonImageFilterParameters: Parameterized Image Filter */
575 typedef struct OMX_CONFIG_IMAGEFILTERPARAMSTYPE {
576    OMX_U32 nSize;
577    OMX_VERSIONTYPE nVersion;
578    OMX_U32 nPortIndex;
579    OMX_IMAGEFILTERTYPE eImageFilter;
580    OMX_U32 nNumParams;
581    OMX_U32 nParams[5];
582 } OMX_CONFIG_IMAGEFILTERPARAMSTYPE;
583 /*
584 This structure contains optional parameters for some image
585 filters. The following table lists all image filters that support
586 parameters.
587
588 <table border="1" cellspacing="0" cellpadding="2">
589 <tr><td>Filter<td>Parameters<td>Notes
590
591 <tr><td>\code{OMX_ImageFilterSolarize}
592 <td>\code{[x0 y0 y1 y2]}
593 <td>Linear mapping of \code{[0,x0]} to \code{[0,y0>]}
594 and \code{[x0,255]} to \code{[y1,y2]}.
595 Default is \code{"128 128 128 0"}.
596
597 <tr><td>\code{OMX_ImageFilterSharpen}
598 <td>\code{[sz [str [th]]}
599 <td>\code{sz} size of filter, either 1 or 2.
600 \code{str} strength of filter.
601 \code{th} threshold of filter.
602 Default is \code{"1 40 20"}.
603
604 <tr><td>\code{OMX_ImageFilterFilm}
605 <td>\code{[[str] [u v]]}
606 <td>\code{str} strength of effect.
607 \code{u} sets u to constant value.
608 \code{v} sets v to constant value.
609 Default is \code{"24"}.
610
611 <tr><td>\code{OMX_ImageFilterBlur}
612 <td>\code{[sz]}
613 <td>\code{sz} size of filter, either 1 or 2.
614 Default is \code{"2"}.
615
616 <tr><td>\code{OMX_ImageFilterSaturation}
617 <td>\code{[str]}
618 <td>\code{str} strength of effect, in 8.8 fixed point format. u/v value
619 differences from 128 are multiplied by \code{str}.
620 Default is \code{"272"}.
621 </table>
622 */
623
624
625 /* OMX_IndexConfigTransitionControl: Transition Control */
626 typedef struct OMX_CONFIG_TRANSITIONCONTROLTYPE {
627    OMX_U32 nSize;
628    OMX_VERSIONTYPE nVersion;
629    OMX_U32 nPortIndex;
630    OMX_U32 nPosStart;
631    OMX_U32 nPosEnd;
632    OMX_S32 nPosIncrement;
633    OMX_TICKS nFrameIncrement;
634    OMX_BOOL bSwapInputs;
635    OMX_U8 name[16];
636    OMX_U8 property[64];
637 } OMX_CONFIG_TRANSITIONCONTROLTYPE;
638 /*
639 This structure represents the internal configuration of the
640 transition. Transitions are generated by a loadable plug-in described
641 by the \code{name} field. The component appends \code{"_tran.vll"} to
642 the name provided, and attempts to load a transition library contained
643 in this VLL.  The exact type of transition is configured in a
644 plug-in-dependent manner with the \code{property} field. All plug-ins
645 should accept a \code{property} field equal to
646 \code{"flags=<number>"}, where \code{<number>} can be a random 32 bit
647 number.  If \code{bSwapInputs} is false, then the start image is on
648 port 210, the stop image on port 211. These are reversed if
649 \code{bSwapInputs} is true.
650
651 Transition frames are generated from the plug-in by referencing a
652 frame position in [0,65536], where position 0 is the start image,
653 position 65536 is the stop image. The first frame position generated
654 is \code{nPosStart}. The last frame position generated is
655 \code{nPosEnd}. Each frame will increment the position by
656 \code{nPosIncrement}. The timestamp attached to each frame will
657 increment by \code{nFrameIncrement}.
658 */
659
660
661 /*
662 This parameter is used to provide a callback function pointer for
663 release events. It is used for internal clients on VideoCore.
664 */
665
666
667 /* OMX_IndexConfigAudioMonoTrackControl: Dual Mono Control */
668 typedef enum OMX_AUDIOMONOTRACKOPERATIONSTYPE {
669    OMX_AUDIOMONOTRACKOPERATIONS_NOP,
670    OMX_AUDIOMONOTRACKOPERATIONS_L_TO_R,
671    OMX_AUDIOMONOTRACKOPERATIONS_R_TO_L,
672    OMX_AUDIOMONOTRACKOPERATIONS_DUMMY = 0x7FFFFFFF
673 } OMX_AUDIOMONOTRACKOPERATIONSTYPE ;
674
675 typedef struct OMX_CONFIG_AUDIOMONOTRACKCONTROLTYPE {
676    OMX_U32 nSize;
677    OMX_VERSIONTYPE nVersion;
678    OMX_U32 nPortIndex;
679    OMX_AUDIOMONOTRACKOPERATIONSTYPE eMode;
680 } OMX_CONFIG_AUDIOMONOTRACKCONTROLTYPE;
681 /*
682 This config controls the options to support dual mono audio
683 streams. The output can be unchanged, or the left channel copied over
684 the right channel, or the right channel copied over the left
685 channel. This config can be applied at any time with stereo
686 16-bit-per-sample data. Since audio output is typically buffered, any
687 change will not be audible until that buffering has been played out.
688 */
689
690 /* OMX_IndexParamCameraImagePool: Camera Image Pools */
691 typedef enum OMX_CAMERAIMAGEPOOLINPUTMODETYPE {
692    OMX_CAMERAIMAGEPOOLINPUTMODE_ONEPOOL,     /*All input images are allocated from one pool
693                                                Works for simple stills capture use cases
694                                                Can not be used with parallel stills capture
695                                                and video encode, as the pool will be sized for
696                                                capture or viewfinder, not both simultaneously.
697                                                The pool wouldn't divide sensibly in this mode
698                                                anyway.
699                                              */
700    OMX_CAMERAIMAGEPOOLINPUTMODE_TWOPOOLS,    /*All stills & video input images are allocated
701                                                from two seperate pools.
702                                                This ensures that parallel capture can work, but
703                                                would consume more memory if used on a simple
704                                                stills capture use case.
705                                              */
706 } OMX_CAMERAIMAGEPOOLINPUTMODETYPE;
707
708 typedef struct OMX_PARAM_CAMERAIMAGEPOOLTYPE {
709    OMX_U32 nSize;
710    OMX_VERSIONTYPE nVersion;
711    OMX_U32 nNumHiResVideoFrames;
712    OMX_U32 nHiResVideoWidth;
713    OMX_U32 nHiResVideoHeight;
714    OMX_COLOR_FORMATTYPE eHiResVideoType;
715    OMX_U32 nNumHiResStillsFrames;
716    OMX_U32 nHiResStillsWidth;
717    OMX_U32 nHiResStillsHeight;
718    OMX_COLOR_FORMATTYPE eHiResStillsType;
719    OMX_U32 nNumLoResFrames;
720    OMX_U32 nLoResWidth;
721    OMX_U32 nLoResHeight;
722    OMX_COLOR_FORMATTYPE eLoResType;
723    OMX_U32 nNumSnapshotFrames;
724    OMX_COLOR_FORMATTYPE eSnapshotType;
725    OMX_CAMERAIMAGEPOOLINPUTMODETYPE eInputPoolMode;
726    OMX_U32 nNumInputVideoFrames;
727    OMX_U32 nInputVideoWidth;
728    OMX_U32 nInputVideoHeight;
729    OMX_COLOR_FORMATTYPE eInputVideoType;
730    OMX_U32 nNumInputStillsFrames;
731    OMX_U32 nInputStillsWidth;
732    OMX_U32 nInputStillsHeight;
733    OMX_COLOR_FORMATTYPE eInputStillsType;
734 } OMX_PARAM_CAMERAIMAGEPOOLTYPE;
735 /*
736 \sloppy This parameter specifies the size, type, and number, of images to
737 allow in the images pools required by Camplus. Supported types are
738 \code{OMX_COLOR_FormatYUV420PackedPlanar},
739 \code{OMX_COLOR_FormatYUV422PackedPlanar},
740 \code{OMX_COLOR_FormatRawBayer8bit},
741 \code{OMX_COLOR_FormatRawBayer10bit},
742 \code{OMX_COLOR_FormatRawBayer8bitcompressed}, and 0 (reserved for the
743 Broadcom-specific format required by the video encoder). The input
744 pool width, height, and type can be set as 0 to make the component
745 query Camplus for the sensor mode that would correspond to the largest
746 of the viewfinder port definition, the capture port definition, or the
747 high resolution image pool.
748 */
749
750 /* OMX_IndexParamImagePoolSize: Specifying Image Pool Properties */
751 typedef struct OMX_PARAM_IMAGEPOOLSIZETYPE {
752    OMX_U32 nSize;
753    OMX_VERSIONTYPE nVersion;
754    OMX_U32 width;
755    OMX_U32 height;
756    OMX_U32 num_pages;
757 } OMX_PARAM_IMAGEPOOLSIZETYPE;
758 /*
759 This parameter is used to control the size of pool that the component
760 will allocate in the absence of setting an external pool.  The default
761 can be reset by setting this parameter with all three fields set to
762 zero.
763 */
764
765
766 /* OMX_IndexParamImagePoolExternal: Client Allocated Image Pools */
767 struct opaque_vc_pool_s;
768 typedef struct opaque_vc_pool_s OMX_BRCM_POOL_T;
769
770 typedef struct OMX_PARAM_IMAGEPOOLEXTERNALTYPE {
771    OMX_U32 nSize;
772    OMX_VERSIONTYPE nVersion;
773    OMX_BRCM_POOL_T *image_pool;
774    OMX_BRCM_POOL_T *image_pool2;
775    OMX_BRCM_POOL_T *image_pool3;
776    OMX_BRCM_POOL_T *image_pool4;
777    OMX_BRCM_POOL_T *image_pool5;
778 } OMX_PARAM_IMAGEPOOLEXTERNALTYPE;
779 /*
780 This config allows the client to pass in handles to pre-allocated
781 image pools for use within the component.
782 */
783
784
785 struct _IL_FIFO_T;
786 typedef struct OMX_PARAM_RUTILFIFOINFOTYPE {
787    OMX_U32 nSize;
788    OMX_VERSIONTYPE nVersion;
789    OMX_U32 nPortIndex;
790    struct _IL_FIFO_T *pILFifo;
791 } OMX_PARAM_RUTILFIFOINFOTYPE;
792
793 /* OMX_IndexParamILFifoConfig: Allows configuration of the FIFO settings. */
794 typedef struct OMX_PARAM_ILFIFOCONFIG {
795    OMX_U32 nSize;
796    OMX_VERSIONTYPE nVersion;
797    OMX_U32 nPortIndex;
798    OMX_U32 nDataSize;         /**< The size of the FIFO's data area */
799    OMX_U32 nHeaderCount;      /**< The number of headers allocated */
800 } OMX_PARAM_ILFIFOCONFIG;
801 /**
802  * Allows configuring the size of the ILFIFO used in a component.
803  */
804
805 /* OMX_IndexConfigCameraSensorModes: Camera Sensor Mode */
806 typedef struct OMX_CONFIG_CAMERASENSORMODETYPE {
807    OMX_U32 nSize;
808    OMX_VERSIONTYPE nVersion;
809    OMX_U32 nPortIndex;
810    OMX_U32 nModeIndex;
811    OMX_U32 nNumModes;
812    OMX_U32 nWidth;
813    OMX_U32 nHeight;
814    OMX_U32 nPaddingRight;
815    OMX_U32 nPaddingDown;
816    OMX_COLOR_FORMATTYPE eColorFormat;
817    OMX_U32 nFrameRateMax;
818    OMX_U32 nFrameRateMin;
819 } OMX_CONFIG_CAMERASENSORMODETYPE;
820 /*
821 This parameter is used by clients to determine the sensor mode, and
822 hence the memory usage, of the camera module. This is primarily used
823 for determining the size of the input image pool.
824
825 It can be used in two ways dependent on \code{nPortIndex}. If
826 \code{nPortIndex} is \code{OMX_ALL}, it returns the sensor mode
827 corresponding to \code{nModeIndex}, and the number of modes in
828 \code{nNumModes}. If \code{nModeIndex} is greater than or equal to
829 \code{nNumModes} only \code{nNumModes} is returned. If
830 \code{nPortIndex} is equal to a camera video output port index, it
831 returns the sensor mode that would be selected for the values
832 currently in \code{OMX_IndexParamPortDefinition} for that port.
833
834 The \code{nPaddingRight} and \code{nPaddingDown} values determine the
835 extra padding the sensor adds to the image. These values must be added
836 to \code{nWidth} and \code{nHeight} respectively if the client is
837 specifying the input image pool size.
838 */
839
840 typedef struct OMX_BRCMBUFFERSTATSTYPE {
841    OMX_U32 nOrdinal;
842    OMX_TICKS nTimeStamp;
843    OMX_U32 nFilledLen;
844    OMX_U32 nFlags;
845    union
846    {
847       OMX_U32 nU32;
848       struct
849       {
850          OMX_U32 nYpart;
851          OMX_U32 nUVpart;
852       } image;
853    } crc;
854 } OMX_BRCMBUFFERSTATSTYPE;
855
856 /*
857 Ports that gather statistics for debugging and diagnostics
858 might also collect information about buffer header fields
859 and data.
860
861 Note that:
862
863 The \code{nOrdinal} field increases monotonically whenever
864 a new buffer is received or emitted and shall not be reset
865 upon a port flush.
866
867 The \code{nFilledLen} might indicate the size of a data area
868 larger than the data area that actually contributed to the
869 checksums (e.g. when image data is provided with cropping
870 information).
871 */
872
873 /* OMX_IndexConfigBrcmPortBufferStats: Query port buffer stats history */
874 typedef struct OMX_CONFIG_BRCMPORTBUFFERSTATSTYPE {
875    OMX_U32 nSize;
876    OMX_VERSIONTYPE nVersion;
877    OMX_U32 nPortIndex;
878    OMX_U32 nCount;
879    OMX_BRCMBUFFERSTATSTYPE sData[1];
880 } OMX_CONFIG_BRCMPORTBUFFERSTATSTYPE;
881 /*
882 Ports that gather statistics for debugging and diagnostics
883 might also collect information about buffer header fields
884 and data.
885
886 The \code{sStatsData} field is a variable length array and
887 the number of items is denoted by \code{nStatsCount}.
888 */
889
890 /* OMX_IndexConfigBrcmPortStats: Query port statistics */
891 typedef struct OMX_CONFIG_BRCMPORTSTATSTYPE {
892    OMX_U32 nSize;
893    OMX_VERSIONTYPE nVersion;
894    OMX_U32 nPortIndex;
895    OMX_U32 nImageCount;
896    OMX_U32 nBufferCount;
897    OMX_U32 nFrameCount;
898    OMX_U32 nFrameSkips;
899    OMX_U32 nDiscards;
900    OMX_U32 nEOS;
901    OMX_U32 nMaxFrameSize;
902
903    OMX_TICKS nByteCount;
904    OMX_TICKS nMaxTimeDelta;
905    OMX_U32 nCorruptMBs;   /**< Number of corrupt macroblocks in the stream */
906 } OMX_CONFIG_BRCMPORTSTATSTYPE;
907 /*
908 Some ports gather various statistics that can be used by clients for
909 debugging purposes.  This structure is the set of all statistics that
910 are gathered.
911
912 The \code{nFrameSkips} field indicates the number of frames that did
913 not have an expected PTS value based on the port frame rate.
914
915 The \code{nByteCount} field is a 64 bit value, that will either use a
916 64 bit type or two 32 bit types, similarly to \code{OMX_TICKS}.
917 */
918
919 /* OMX_IndexConfigBrcmClockMissCount: Missed clock request accounting */
920 /*
921 For each port on the clock component, requests for media times may be
922 made.  These are typically done one per video frame to allow for
923 scheduling the display of that frame at the correct time.  If a
924 request is made after the time has occured, then that frame will be
925 displayed late, and the clock component keeps a per-port record of the
926 number of times this occurs.  This record can be read using this
927 index.
928 */
929
930 typedef struct OMX_CONFIG_BRCMCAMERASTATSTYPE {
931    OMX_U32 nSize;
932    OMX_VERSIONTYPE nVersion;
933    OMX_U32 nOutFrameCount;
934    OMX_U32 nDroppedFrameCount;
935 } OMX_CONFIG_BRCMCAMERASTATSTYPE;
936
937 // for backward compatibility
938 typedef struct OMX_CONFIG_BRCMCAMERASTATSTYPE OMX_CONFIG_BRCMCAMERASTATS;
939
940
941 #define OMX_BRCM_MAXIOPERFBANDS 10
942 typedef struct {
943    OMX_U32 count[OMX_BRCM_MAXIOPERFBANDS];
944    OMX_U32 num[OMX_BRCM_MAXIOPERFBANDS];
945 } OMX_BRCM_PERFSTATS;
946
947 /* OMX_IndexConfigBrcmIOPerfStats: Query I/O performance statistics */
948 typedef struct OMX_CONFIG_BRCMIOPERFSTATSTYPE {
949    OMX_U32 nSize;
950    OMX_VERSIONTYPE nVersion;
951    OMX_BOOL bEnabled;                              /**< Enable/disable I/O performance statistics */
952    OMX_BRCM_PERFSTATS write; /**< count:bytes     num:microseconds */
953    OMX_BRCM_PERFSTATS flush; /**< count:frequency num:microseconds waiting to flush data */
954    OMX_BRCM_PERFSTATS wait;  /**< count:frequency num:microseconds waiting in calling function */
955 } OMX_CONFIG_BRCMIOPERFSTATSTYPE;
956 /*
957 A sink component can gather various statistics about I/O (eg. file media) performance that can be used by
958 clients for debugging purposes.  The \code{bEnabled} field is used to turn the gathering of statistics
959 on/off.
960 */
961
962 typedef struct OMX_CONFIG_SHARPNESSTYPE {
963    OMX_U32 nSize;
964    OMX_VERSIONTYPE nVersion;
965    OMX_U32 nPortIndex;
966    OMX_S32 nSharpness;
967 } OMX_CONFIG_SHARPNESSTYPE;
968
969 /* OMX_IndexConfigCommonFlickerCancellation: Flicker cancellation */
970 typedef enum OMX_COMMONFLICKERCANCELTYPE {
971    OMX_COMMONFLICKERCANCEL_OFF,
972    OMX_COMMONFLICKERCANCEL_AUTO,
973    OMX_COMMONFLICKERCANCEL_50,
974    OMX_COMMONFLICKERCANCEL_60,
975    OMX_COMMONFLICKERCANCEL_DUMMY = 0x7FFFFFFF
976 } OMX_COMMONFLICKERCANCELTYPE;
977
978 typedef struct OMX_CONFIG_FLICKERCANCELTYPE {
979    OMX_U32 nSize;
980    OMX_VERSIONTYPE nVersion;
981    OMX_U32 nPortIndex;
982    OMX_COMMONFLICKERCANCELTYPE eFlickerCancel;
983 } OMX_CONFIG_FLICKERCANCELTYPE;
984 /*
985 Query / set the flicker cancellation frequency. Values are defined for Off,
986 50Hz, 60Hz, or auto. The method for auto detecting the flicker frequency is
987 not defined, and currently results in the feature being turned off.
988 */
989
990 /* OMX_IndexConfigCommonRedEyeRemoval: Red eye removal/reduction */
991 typedef enum OMX_REDEYEREMOVALTYPE {
992    OMX_RedEyeRemovalNone,                           /**< No red eye removal */
993    OMX_RedEyeRemovalOn,                             /**< Red eye removal on */
994    OMX_RedEyeRemovalAuto,                           /**< Red eye removal will be done automatically when detected */
995    OMX_RedEyeRemovalKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
996    OMX_RedEyeRemovalVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
997    OMX_RedEyeRemovalSimple,                         /**< Use simple red eye reduction mechanism if supported by algorithm */
998    OMX_RedEyeRemovalMax = 0x7FFFFFFF
999 } OMX_REDEYEREMOVALTYPE;
1000
1001 typedef struct OMX_CONFIG_REDEYEREMOVALTYPE {
1002    OMX_U32 nSize;
1003    OMX_VERSIONTYPE nVersion;
1004    OMX_U32 nPortIndex;
1005    OMX_REDEYEREMOVALTYPE eMode;
1006 } OMX_CONFIG_REDEYEREMOVALTYPE;
1007 /*
1008    Configures the red eye reduction algorithm in the camera processing
1009    pipeline. The stage is only enabled if the flash mode is not FlashOff.
1010    The OMX_RedEyeRemovalSimple mode requests that the algorithm uses a
1011    reduced complexity algorithm to reduce the processing time.
1012 */
1013
1014
1015 typedef enum OMX_FACEDETECTIONCONTROLTYPE {
1016    OMX_FaceDetectionControlNone,                           /**< Disables face detection */
1017    OMX_FaceDetectionControlOn,                             /**< Enables face detection */
1018    OMX_FaceDetectionControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
1019    OMX_FaceDetectionControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
1020    OMX_FaceDetectionControlMax = 0x7FFFFFFF
1021 } OMX_FACEDETECTIONCONTROLTYPE;
1022
1023 typedef struct OMX_CONFIG_FACEDETECTIONCONTROLTYPE {
1024    OMX_U32 nSize;
1025    OMX_VERSIONTYPE nVersion;
1026    OMX_U32 nPortIndex;
1027    OMX_FACEDETECTIONCONTROLTYPE eMode;
1028    OMX_U32 nFrames;      /**< number of frames to apply this setting for,
1029                               0 for unlimited */
1030    OMX_U32 nMaxRegions;  /**< maximum number of regions to detect, 0 for unlimited */
1031    OMX_U32 nQuality;     /**< hint for algorithmic complexity, range is 0-100.
1032                               0 for simplest algorithm, 100 for best quality */
1033 } OMX_CONFIG_FACEDETECTIONCONTROLTYPE;
1034
1035 typedef enum OMX_FACEREGIONFLAGSTYPE {
1036    OMX_FaceRegionFlagsNone    = 0,
1037    OMX_FaceRegionFlagsBlink   = 1,
1038    OMX_FaceRegionFlagsSmile   = 2,
1039    OMX_FaceRegionFlagsKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
1040    OMX_FaceRegionFlagsVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
1041    OMX_FaceRegionFlagsMax = 0x7FFFFFFF
1042 } OMX_FACEREGIONFLAGSTYPE;
1043
1044 typedef struct OMX_FACEREGIONTYPE {
1045    OMX_S16 nLeft;              /**< X Coordinate of the top left corner of the rectangle */
1046    OMX_S16 nTop;               /**< Y Coordinate of the top left corner of the rectangle */
1047    OMX_U16 nWidth;             /**< Width of the rectangle */
1048    OMX_U16 nHeight;            /**< Height of the rectangle */
1049    OMX_FACEREGIONFLAGSTYPE nFlags;  /**< Flags for the region */
1050 #ifndef OMX_SKIP64BIT
1051    OMX_U64 nFaceRecognitionId; /**< ID returned by face recognition for this face */
1052 #else
1053    struct
1054    {
1055       OMX_U32 nLowPart;   /**< low bits of the signed 64 bit value */
1056       OMX_U32 nHighPart;  /**< high bits of the signed 64 bit value */
1057    } nFaceRecognitionId;
1058 #endif
1059 } OMX_FACEREGIONTYPE;
1060
1061 typedef struct OMX_CONFIG_FACEDETECTIONREGIONTYPE {
1062    OMX_U32 nSize;
1063    OMX_VERSIONTYPE nVersion;
1064    OMX_U32 nPortIndex;            /**< index of port with face detection enabled */
1065    OMX_U32 nIndex;                /**< first requested region number, allowing retrieval of many regions
1066                                        over several requests */
1067    OMX_U32 nDetectedRegions;      /**< total number of detected regions */
1068    OMX_S32 nValidRegions;         /**< number of valid regions in sRegion array
1069                                        When getting, the client sets this to the number of regions available.
1070                                        The component writes region data and updates this field with how many
1071                                        regions have been written to. */
1072    OMX_U32 nImageWidth;           /**< Width of the image, hence reference for the face coordinates */
1073    OMX_U32 nImageHeight;          /**< Height of the image, hence reference for the face coordinates */
1074    OMX_FACEREGIONTYPE sRegion[1]; /**< variable length array of face regions */
1075 } OMX_CONFIG_FACEDETECTIONREGIONTYPE;
1076
1077 typedef enum OMX_INTERLACETYPE {
1078    OMX_InterlaceProgressive,                    /**< The data is not interlaced, it is progressive scan */
1079    OMX_InterlaceFieldSingleUpperFirst,          /**< The data is interlaced, fields sent
1080                                                      separately in temporal order, with upper field first */
1081    OMX_InterlaceFieldSingleLowerFirst,          /**< The data is interlaced, fields sent
1082                                                      separately in temporal order, with lower field first */
1083    OMX_InterlaceFieldsInterleavedUpperFirst,    /**< The data is interlaced, two fields sent together line
1084                                                      interleaved, with the upper field temporally earlier */
1085    OMX_InterlaceFieldsInterleavedLowerFirst,    /**< The data is interlaced, two fields sent together line
1086                                                      interleaved, with the lower field temporally earlier */
1087    OMX_InterlaceMixed,                          /**< The stream may contain a mixture of progressive
1088                                                      and interlaced frames */
1089    OMX_InterlaceKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
1090    OMX_InterlaceVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
1091    OMX_InterlaceMax = 0x7FFFFFFF
1092 } OMX_INTERLACETYPE;
1093
1094 typedef struct OMX_CONFIG_INTERLACETYPE {
1095    OMX_U32 nSize;
1096    OMX_VERSIONTYPE nVersion;
1097    OMX_U32 nPortIndex;            /**< index of port emitting or accepting the content */
1098    OMX_INTERLACETYPE eMode;       /**< The interlace type of the content */
1099    OMX_BOOL bRepeatFirstField;    /**< Whether to repeat the first field */
1100 } OMX_CONFIG_INTERLACETYPE;
1101
1102 /* OMX_IndexParamIspTuner: Custom ISP tuner */
1103 typedef struct OMX_PARAM_CAMERAISPTUNERTYPE {
1104    OMX_U32 nSize;
1105    OMX_VERSIONTYPE nVersion;
1106    OMX_U8 tuner_name[64];
1107 } OMX_PARAM_CAMERAISPTUNERTYPE;
1108 /*
1109 This parameter allows a custom ISP tuner to be loaded instead of
1110 the default one specified for the camera module. Setting an empty
1111 string uses the default value.
1112 */
1113
1114 /* OMX_IndexConfigCameraInputFrame: Pointer to the raw input image */
1115 typedef struct OMX_CONFIG_IMAGEPTRTYPE {
1116    OMX_U32 nSize;
1117    OMX_VERSIONTYPE nVersion;
1118    OMX_PTR pImage;
1119 } OMX_CONFIG_IMAGEPTRTYPE;
1120 /*
1121 This parameter parameter allows the return of a pointer to a
1122 VideoCore image resource.
1123 */
1124
1125 /* OMX_IndexConfigAFAssistLight: Autofocus assist light mode selection */
1126 typedef enum OMX_AFASSISTTYPE {
1127    OMX_AFAssistAuto,
1128    OMX_AFAssistOn,
1129    OMX_AFAssistOff,
1130    OMX_AFAssistTorch,
1131    OMX_AFAssistKhronosExtensions = 0x6F000000,
1132    OMX_AFAssistVendorStartUnused = 0x7F000000,
1133    OMX_AFAssistMax = 0x7FFFFFFF
1134 } OMX_AFASSISTTYPE;
1135
1136 typedef struct OMX_CONFIG_AFASSISTTYPE {
1137    OMX_U32 nSize;
1138    OMX_VERSIONTYPE nVersion;
1139    OMX_U32 nPortIndex;
1140    OMX_AFASSISTTYPE eMode;
1141 } OMX_CONFIG_AFASSISTTYPE;
1142 /*
1143 Set the mode to adopt for the autofocus assist light.
1144 \code{OMX_AFAssistTorch} will turn the AF assist light on permanently, allowing
1145 it to be used as a torch.
1146 */
1147
1148 /* OMX_IndexConfigInputCropPercentage: Specify input crop as a percentage */
1149 typedef struct OMX_CONFIG_INPUTCROPTYPE {
1150    OMX_U32 nSize;
1151    OMX_VERSIONTYPE nVersion;
1152    OMX_U32 nPortIndex;
1153    OMX_U32 xLeft;     /**< Fraction of the width for the top left corner of the rectangle */
1154    OMX_U32 xTop;      /**< Fraction of the height for the top left corner of the rectangle */
1155    OMX_U32 xWidth;    /**< Fraction of the image width desired */
1156    OMX_U32 xHeight;   /**< Fraction of the image height desired */
1157 } OMX_CONFIG_INPUTCROPTYPE;
1158 /*
1159 This parameter allows the input cropping to be specified as a
1160 percentage of the current width/height.  Required for the camera
1161 component where the output resolution varies dependent on the port.
1162 All percentage values are as 16p16 fixed point numbers (0x10000 =
1163 100\%)
1164 */
1165
1166 /* OMX_IndexParamCodecRequirements: Advanced codec requirements */
1167 typedef struct OMX_PARAM_CODECREQUIREMENTSTYPE {
1168    OMX_U32 nSize;
1169    OMX_VERSIONTYPE nVersion;
1170    OMX_U32 nCallbackID;
1171    OMX_BOOL bTryHWCodec;
1172 } OMX_PARAM_CODECREQUIREMENTSTYPE;
1173 /*
1174 This parameter allows internal users of RIL components controlling
1175 video codecs to request that the component loads the component and
1176 queries for requirements.  The component will perform a callback with
1177 the given nCallbackID value passing a pointer to the requirements
1178 structure as the data field.
1179 */
1180
1181 /* OMX_IndexConfigBrcmEGLImageMemHandle: Mapping from an EGLImage to a VideoCore mem handle */
1182 typedef struct OMX_CONFIG_BRCMEGLIMAGEMEMHANDLETYPE {
1183    OMX_U32 nSize;
1184    OMX_VERSIONTYPE nVersion;
1185    OMX_U32 nPortIndex;
1186    OMX_PTR eglImage;
1187    OMX_PTR memHandle;
1188 } OMX_CONFIG_BRCMEGLIMAGEMEMHANDLETYPE;
1189 /*
1190 This config allows the EGL server to notify a RIL component that an
1191 EGLImage is available for rendering into and to provide a mapping from
1192 an EGLImage to a mem handle.
1193 */
1194
1195 /* OMX_IndexConfigPrivacyIndicator: Privacy indicator control */
1196 typedef enum OMX_PRIVACYINDICATORTYPE {
1197    OMX_PrivacyIndicatorOff,
1198    OMX_PrivacyIndicatorOn,
1199    OMX_PrivacyIndicatorForceOn,
1200    OMX_PrivacyIndicatorKhronosExtensions = 0x6F000000,
1201    OMX_PrivacyIndicatorVendorStartUnused = 0x7F000000,
1202    OMX_PrivacyIndicatorMax = 0x7FFFFFFF
1203 } OMX_PRIVACYINDICATORTYPE;
1204
1205 typedef struct OMX_CONFIG_PRIVACYINDICATORTYPE {
1206    OMX_U32 nSize;
1207    OMX_VERSIONTYPE nVersion;
1208    OMX_PRIVACYINDICATORTYPE ePrivacyIndicatorMode;
1209 } OMX_CONFIG_PRIVACYINDICATORTYPE;
1210 /*
1211 This config allows control over the privacy indicator light.  This
1212 light indicates when a capture is in progress.
1213
1214 \code{OMX_PrivacyIndicatorOff} indicator is disabled.
1215
1216 \code{OMX_PrivacyIndicatorOn} indicator will be
1217 turned on whenever an image is being captured as determined by the
1218 capturing bit. Minimum on duration of approx 200ms.
1219
1220 \code{OMX_PrivacyIndicatorForceOn} results in turning the indicator on
1221 immediately, whether an image is being captured or not. The mode will
1222 automatically revert to \code{OMX_PrivacyIndicatorOff} once the
1223 indicator has been turned on, so \code{OMX_PrivacyIndicatorForceOn}
1224 must be requested at least every 200ms if the indicator is to remain
1225 on.
1226 */
1227
1228
1229 /* OMX_IndexParamCameraFlashType: Select flash type */
1230 typedef enum OMX_CAMERAFLASHTYPE {
1231    OMX_CameraFlashDefault,
1232    OMX_CameraFlashXenon,
1233    OMX_CameraFlashLED,
1234    OMX_CameraFlashNone,
1235    OMX_CameraFlashKhronosExtensions = 0x6F000000,
1236    OMX_CameraFlashVendorStartUnused = 0x7F000000,
1237    OMX_CameraFlashMax = 0x7FFFFFFF
1238 } OMX_CAMERAFLASHTYPE;
1239
1240 typedef struct OMX_PARAM_CAMERAFLASHTYPE {
1241    OMX_U32 nSize;
1242    OMX_VERSIONTYPE nVersion;
1243    OMX_U32 nPortIndex;
1244    OMX_CAMERAFLASHTYPE eFlashType;
1245    OMX_BOOL bRedEyeUsesTorchMode;
1246 } OMX_PARAM_CAMERAFLASHTYPE;
1247 /*
1248 This parameter allows the selection of xenon or LED flash devices
1249 to be used with the currently selected camera. If that device is not
1250 available, then the component will revert back to whatever flash
1251 device is available for that camera.
1252 \code{bRedEyeUsesTorchMode} allows the blinking for red eye reduction to
1253 be switched between using the indicator mode, and the torch mode for the
1254 flash driver.
1255 */
1256
1257 /* OMX_IndexConfigCameraFlashConfig: Flash cycle configuration */
1258 typedef enum OMX_CAMERAFLASHCONFIGSYNCTYPE {
1259    OMX_CameraFlashConfigSyncFrontSlow,
1260    OMX_CameraFlashConfigSyncRearSlow,
1261    OMX_CameraFlashConfigSyncFrontFast,
1262    OMX_CameraFlashConfigSyncKhronosExtensions = 0x6F000000,
1263    OMX_CameraFlashConfigSyncVendorStartUnused = 0x7F000000,
1264    OMX_CameraFlashConfigSyncMax = 0x7FFFFFFF
1265 } OMX_CAMERAFLASHCONFIGSYNCTYPE;
1266
1267 typedef struct OMX_CONFIG_CAMERAFLASHCONFIGTYPE {
1268    OMX_U32 nSize;
1269    OMX_VERSIONTYPE nVersion;
1270    OMX_U32 nPortIndex;
1271    OMX_BOOL bUsePreFlash;
1272    OMX_BOOL bUseFocusDistanceInfo;
1273    OMX_CAMERAFLASHCONFIGSYNCTYPE eFlashSync;
1274    OMX_BOOL bIgnoreChargeState;
1275 } OMX_CONFIG_CAMERAFLASHCONFIGTYPE;
1276 /*
1277 This parameter allows the configuration of various parameters relating to
1278 the flash cycle. Some of the options are only applicable to xenon flash.
1279
1280 \code{bUsePreFlash} uses a low intensity pre-flash to determine flash intensity. This setting
1281 is recommended for almost all flash situations.
1282
1283 \code{bUseFocusDistanceInfo} uses the distance of the subject, as measured by the AF algorithm
1284 to set the intensity of the flash.
1285
1286 \code{eFlashSync} configures which edge of the shutter is used to synchronise the flash, and
1287 the duration of the exposure.
1288
1289 \code{eIgnoreChargeState} will make the flash fire, even if it is not fully charged.
1290 */
1291
1292 /* OMX_IndexConfigBrcmAudioTrackGaplessPlayback: Encoder/decoder delay and padding information for gapless playback. */
1293 typedef struct OMX_CONFIG_BRCMAUDIOTRACKGAPLESSPLAYBACKTYPE {
1294    OMX_U32 nSize;
1295    OMX_VERSIONTYPE nVersion;
1296    OMX_U32 nPortIndex;
1297    OMX_U32 nDelay;   /**< number of samples delay added by the codec */
1298    OMX_U32 nPadding; /**< number of silent samples added to the end */
1299 } OMX_CONFIG_BRCMAUDIOTRACKGAPLESSPLAYBACKTYPE;
1300 /*
1301 This config allows communication between components to facilitate gapless playback.
1302 */
1303
1304
1305 /* OMX_IndexConfigBrcmAudioTrackChangeControl: Configure gapless/crossfaded audio track change. */
1306 typedef struct OMX_CONFIG_BRCMAUDIOTRACKCHANGECONTROLTYPE {
1307    OMX_U32 nSize;
1308    OMX_VERSIONTYPE nVersion;
1309    OMX_U32 nSrcPortIndex;
1310    OMX_U32 nDstPortIndex;
1311    OMX_U32 nXFade;
1312 } OMX_CONFIG_BRCMAUDIOTRACKCHANGECONTROLTYPE;
1313 /*
1314 This config allows the client to specify the gapless or crossfade
1315 parameters to be used on a track change.  If \code{nXFade} is 0, then
1316 a normal or gapless track change will result, otherwise a crossfade of
1317 \code{nXFade} ms is used.
1318 */
1319
1320 /* OMX_IndexParamBrcmPixelValueRange: Describing the pixel value range */
1321 typedef enum OMX_BRCMPIXELVALUERANGETYPE
1322 {
1323    OMX_PixelValueRangeUnspecified = 0,
1324    OMX_PixelValueRangeITU_R_BT601,
1325    OMX_PixelValueRangeFull8Bit,
1326    OMX_PixelValueRangeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
1327    OMX_PixelValueRangeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
1328    OMX_PixelValueRangeMax = 0x7FFFFFFF
1329 } OMX_BRCMPIXELVALUERANGETYPE;
1330
1331 typedef struct OMX_PARAM_BRCMPIXELVALUERANGETYPE
1332 {
1333    OMX_U32 nSize;
1334    OMX_VERSIONTYPE nVersion;
1335    OMX_U32 nPortIndex;
1336    OMX_BRCMPIXELVALUERANGETYPE ePixelValueRange;
1337 } OMX_PARAM_BRCMPIXELVALUERANGETYPE;
1338 /*
1339 This structure allows a description of the range that pixel values may
1340 have.  This is typically useful since some standards use the full 8
1341 bit range, whereas others introduce pedastals which reduce the range
1342 at the top and bottom end.
1343 */
1344
1345 /* OMX_IndexParamCameraDisableAlgorithm: Disabling camera processing stages. */
1346 typedef enum OMX_CAMERADISABLEALGORITHMTYPE {
1347       OMX_CameraDisableAlgorithmFacetracking,
1348       OMX_CameraDisableAlgorithmRedEyeReduction,
1349       OMX_CameraDisableAlgorithmVideoStabilisation,
1350       OMX_CameraDisableAlgorithmWriteRaw,
1351       OMX_CameraDisableAlgorithmVideoDenoise,
1352       OMX_CameraDisableAlgorithmStillsDenoise,
1353       OMX_CameraDisableAlgorithmAntiShake,
1354       OMX_CameraDisableAlgorithmImageEffects,
1355       OMX_CameraDisableAlgorithmDarkSubtract,
1356       OMX_CameraDisableAlgorithmDynamicRangeExpansion,
1357       OMX_CameraDisableAlgorithmFaceRecognition,
1358       OMX_CameraDisableAlgorithmFaceBeautification,
1359       OMX_CameraDisableAlgorithmSceneDetection,
1360       OMX_CameraDisableAlgorithmHighDynamicRange,
1361    OMX_CameraDisableAlgorithmKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
1362    OMX_CameraDisableAlgorithmVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
1363    OMX_CameraDisableAlgorithmMax = 0x7FFFFFFF
1364 } OMX_CAMERADISABLEALGORITHMTYPE;
1365
1366 typedef struct OMX_PARAM_CAMERADISABLEALGORITHMTYPE
1367 {
1368    OMX_U32 nSize;
1369    OMX_VERSIONTYPE nVersion;
1370    OMX_CAMERADISABLEALGORITHMTYPE eAlgorithm;
1371    OMX_BOOL bDisabled;
1372 } OMX_PARAM_CAMERADISABLEALGORITHMTYPE;
1373 /*
1374 Allows plugin algorithms to be disabled to save memory
1375 within the camera component
1376 */
1377
1378 /* OMX_IndexConfigBrcmAudioEffectControl: Audio Effect Control */
1379 typedef struct OMX_CONFIG_BRCMAUDIOEFFECTCONTROLTYPE {
1380    OMX_U32 nSize;
1381    OMX_VERSIONTYPE nVersion;
1382    OMX_U32 nPortIndex;
1383    OMX_BOOL bEnable;
1384    OMX_U8 name[16];
1385    OMX_U8 property[256];
1386 } OMX_CONFIG_BRCMAUDIOEFFECTCONTROLTYPE;
1387 /*
1388 This structure represents the internal configuration of an audio effect.
1389 The audio effect is provided by a loadable plug-in described
1390 in the \code{name} field and is configured in a plug-in-dependent
1391 manner with the \code{property} field. The \code{bEnable} field is used to
1392 turn the effect on/off.
1393 */
1394
1395 /* OMX_IndexConfigBrcmMinimumProcessingLatency: Processing Latency Bound */
1396 typedef struct OMX_CONFIG_BRCMMINIMUMPROCESSINGLATENCY {
1397    OMX_U32 nSize;
1398    OMX_VERSIONTYPE nVersion;
1399    OMX_TICKS nOffset;
1400 } OMX_CONFIG_BRCMMINIMUMPROCESSINGLATENCY;
1401 /*
1402 Query/set the difference between the actual media time and when the
1403 component receives request fulfillments for media time requests. This
1404 can be used with e.g. splitter/mixer components to control when the
1405 component stops waiting for input or output packets from active
1406 streams and continues with processing (to maintain a constant
1407 processing rate).
1408 */
1409
1410 /** Enable or disable Supplemental Enhancment Information (SEI) messages to be inserted in
1411   * the H.264 bitstream.
1412   */
1413 typedef struct OMX_PARAM_BRCMVIDEOAVCSEIENABLETYPE {
1414    OMX_U32 nSize;
1415    OMX_VERSIONTYPE nVersion;
1416    OMX_U32 nPortIndex;
1417    OMX_BOOL bEnable;
1418 } OMX_PARAM_BRCMVIDEOAVCSEIENABLETYPE;
1419
1420 /* OMX_IndexParamBrcmAllowMemChange: Allowing changing memory allocation on state transition */
1421 typedef struct OMX_PARAM_BRCMALLOWMEMCHANGETYPE {
1422    OMX_U32 nSize;
1423    OMX_VERSIONTYPE nVersion;
1424    OMX_BOOL bEnable;
1425 } OMX_PARAM_BRCMALLOWMEMCHANGETYPE;
1426 /*
1427 Let the component change the amount of memory it has allocated when
1428 going from LOADED to IDLE. By default this is enabled, but if it is
1429 disabled the component will fail to transition to IDLE if the
1430 component requires more memory than has already been allocated.  This
1431 might occur if (for example) the component was configured, taken to
1432 IDLE, then taken back to LOADED, the profile increased and the
1433 component taken back to IDLE.
1434 */
1435
1436 typedef enum OMX_CONFIG_CAMERAUSECASE {
1437    OMX_CameraUseCaseAuto,
1438    OMX_CameraUseCaseVideo,
1439    OMX_CameraUseCaseStills,
1440    OMX_CameraUseCaseKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
1441    OMX_CameraUseCaseVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
1442    OMX_CameraUseCaseMax = 0x7FFFFFFF
1443 } OMX_CONFIG_CAMERAUSECASE;
1444
1445 typedef struct OMX_CONFIG_CAMERAUSECASETYPE {
1446    OMX_U32 nSize;
1447    OMX_VERSIONTYPE nVersion;
1448    OMX_CONFIG_CAMERAUSECASE eUseCase;
1449 } OMX_CONFIG_CAMERAUSECASETYPE;
1450
1451 /* OMX_IndexParamBrcmDisableProprietaryTunnels: Disabling proprietary tunnelling */
1452 typedef struct OMX_PARAM_BRCMDISABLEPROPRIETARYTUNNELSTYPE {
1453    OMX_U32 nSize;
1454    OMX_VERSIONTYPE nVersion;
1455    OMX_U32 nPortIndex;
1456    OMX_BOOL bUseBuffers;
1457 }  OMX_PARAM_BRCMDISABLEPROPRIETARYTUNNELSTYPE;
1458 /*
1459 Tell a source component to refuse to support proprietary tunnelling. Buffers will be used instead.
1460 */
1461
1462
1463 //
1464 // Control for memory allocation and component-internal buffering
1465 //
1466
1467 /* OMX_IndexParamBrcmRetainMemory: Controlling memory use on state transition */
1468 typedef struct OMX_PARAM_BRCMRETAINMEMORYTYPE
1469 {
1470    OMX_U32 nSize;
1471    OMX_VERSIONTYPE nVersion;
1472    OMX_BOOL bEnable;
1473 } OMX_PARAM_BRCMRETAINMEMORYTYPE;
1474 /*
1475 Ask a component to retain its memory when going from IDLE to LOADED, if possible.
1476 This has the benefit that you are then guaranteed that the transition to IDLE cannot
1477 fail due to lack of memory, but has the disadvantage that you cannot leave the component
1478 lying around in LOADED, unused, since it is using significant amounts of memory.
1479 */
1480
1481 /** Tell write media how large the output buffer should be. This is a hint, and
1482   * may be ignored. A good size is bandwidth*<SDcard-delay>, which works out at
1483   * around 1Mbyte for up to 16Mbit/s. Sizes may (and probably will) be rounded down
1484   * to the nearest power of 2.
1485   */
1486 typedef struct OMX_PARAM_BRCMOUTPUTBUFFERSIZETYPE {
1487    OMX_U32 nSize;
1488    OMX_VERSIONTYPE nVersion;
1489    OMX_U32 nBufferSize;
1490 } OMX_PARAM_BRCMOUTPUTBUFFERSIZETYPE;
1491
1492 /* OMX_IndexConfigCameraInfo: Camera device driver information */
1493 #define OMX_CONFIG_CAMERAINFOTYPE_NAME_LEN 16
1494 typedef struct OMX_CONFIG_LENSCALIBRATIONVALUETYPE
1495 {
1496    OMX_U16  nShutterDelayTime;
1497    OMX_U16  nNdTransparency;
1498    OMX_U16  nPwmPulseNearEnd;  /**< Num pulses to move lens 1um at near end */
1499    OMX_U16  nPwmPulseFarEnd;   /**< Num pulses to move lens 1um at far end */
1500    OMX_U16  nVoltagePIOutNearEnd[3];
1501    OMX_U16  nVoltagePIOut10cm[3];
1502    OMX_U16  nVoltagePIOutInfinity[3];
1503    OMX_U16  nVoltagePIOutFarEnd[3];
1504    OMX_U32  nAdcConversionNearEnd;
1505    OMX_U32  nAdcConversionFarEnd;
1506 } OMX_CONFIG_LENSCALIBRATIONVALUETYPE;
1507 /*
1508 Ask the camera component for the driver info on the current camera device
1509 */
1510
1511 #define OMX_CONFIG_CAMERAINFOTYPE_NAME_LEN 16
1512 #define OMX_CONFIG_CAMERAINFOTYPE_SERIALNUM_LEN 20
1513 #define OMX_CONFIG_CAMERAINFOTYPE_EPROMVER_LEN 8
1514 typedef struct OMX_CONFIG_CAMERAINFOTYPE
1515 {
1516    OMX_U32 nSize;
1517    OMX_VERSIONTYPE nVersion;
1518    OMX_U8 cameraname[OMX_CONFIG_CAMERAINFOTYPE_NAME_LEN];
1519    OMX_U8 lensname[OMX_CONFIG_CAMERAINFOTYPE_NAME_LEN];
1520    OMX_U16 nModelId;
1521    OMX_U8 nManufacturerId;
1522    OMX_U8 nRevNum;
1523    OMX_U8 sSerialNumber[OMX_CONFIG_CAMERAINFOTYPE_SERIALNUM_LEN];
1524    OMX_U8 sEpromVersion[OMX_CONFIG_CAMERAINFOTYPE_EPROMVER_LEN];
1525    OMX_CONFIG_LENSCALIBRATIONVALUETYPE sLensCalibration;
1526    OMX_U32 xFNumber;
1527    OMX_U32 xFocalLength;
1528 } OMX_CONFIG_CAMERAINFOTYPE;
1529
1530
1531 typedef enum OMX_CONFIG_CAMERAFEATURESSHUTTER {
1532    OMX_CameraFeaturesShutterUnknown,
1533    OMX_CameraFeaturesShutterNotPresent,
1534    OMX_CameraFeaturesShutterPresent,
1535    OMX_CameraFeaturesShutterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
1536    OMX_CameraFeaturesShutterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
1537    OMX_CameraFeaturesShutterMax = 0x7FFFFFFF
1538 } OMX_CONFIG_CAMERAFEATURESSHUTTER;
1539
1540 typedef struct OMX_CONFIG_CAMERAFEATURESTYPE
1541 {
1542    OMX_U32 nSize;
1543    OMX_VERSIONTYPE nVersion;
1544    OMX_CONFIG_CAMERAFEATURESSHUTTER eHasMechanicalShutter;
1545    OMX_BOOL bHasLens;
1546 } OMX_CONFIG_CAMERAFEATURESTYPE;
1547
1548
1549 //Should be added to the spec as part of IL416c
1550 /* OMX_IndexConfigRequestCallback: Enable config change notifications. */
1551 typedef struct OMX_CONFIG_REQUESTCALLBACKTYPE
1552 {
1553    OMX_U32 nSize;
1554    OMX_VERSIONTYPE nVersion;
1555    OMX_U32 nPortIndex;
1556    OMX_INDEXTYPE nIndex;
1557    OMX_BOOL bEnable;
1558 } OMX_CONFIG_REQUESTCALLBACKTYPE;
1559 /*
1560 This config implements IL416c to allow clients to request notification
1561 of when a config or parameter is changed. When the parameter specified
1562 in \code{nIndex} for port \code{nPortIndex} changes, an
1563 \code{OMX_EventParamOrConfigChanged} event is generated for the client.
1564 */
1565
1566 /* OMX_IndexConfigCommonFocusRegionXY: Define focus regions */
1567 typedef enum OMX_FOCUSREGIONTYPE {
1568    OMX_FocusRegionNormal,
1569    OMX_FocusRegionFace,
1570    OMX_FocusRegionMax
1571 } OMX_FOCUSREGIONTYPE;
1572
1573 typedef struct OMX_FOCUSREGIONXY {
1574    OMX_U32 xLeft;
1575    OMX_U32 xTop;
1576    OMX_U32 xWidth;
1577    OMX_U32 xHeight;
1578    OMX_U32 nWeight;
1579    OMX_U32 nMask;
1580    OMX_FOCUSREGIONTYPE eType;
1581 } OMX_FOCUSREGIONXY;
1582
1583 typedef struct OMX_CONFIG_FOCUSREGIONXYTYPE
1584 {
1585    OMX_U32 nSize;
1586    OMX_VERSIONTYPE nVersion;
1587    OMX_U32 nPortIndex;
1588    OMX_U32 nIndex;
1589    OMX_U32 nTotalRegions;
1590    OMX_S32 nValidRegions;
1591    OMX_BOOL bLockToFaces;
1592    OMX_U32 xFaceTolerance;
1593    OMX_FOCUSREGIONXY sRegion[1];
1594 } OMX_CONFIG_FOCUSREGIONXYTYPE;
1595 /*
1596 Query / set the focus regions to use as a set of x/y/width/height boxes relative
1597 to the overall image.
1598
1599 \code{nIndex} - first region number being set/read, allowing retrieval/setting
1600 of many regions over several requests.
1601
1602 \code{nTotalRegions} - total number of regions currently defined.
1603
1604 \code{nValidRegions} - number of valid regions in the \code{sRegion} array.
1605 When getting, the client sets this to the number of regions available.
1606 The component writes region data and updates this field with how many
1607 regions have been written to.
1608 When setting, this is the number of regions defined with this structure
1609
1610 \code{bLockToFaces} - compare the region(s) given to the latest face tracking results.
1611 If a face is found within xFaceTolerance of the defined region, then amend the
1612 region to correspond to the face.
1613
1614 \code{xFaceTolerance} - 0p16 value to define the max difference between the region centre
1615 and face tracking result centre to take the FT results
1616
1617 \code{sRegions} - variable length array of focus regions.
1618 */
1619
1620 typedef struct OMX_CONFIG_U8TYPE {
1621     OMX_U32 nSize;                    /**< Size of this structure, in Bytes */
1622     OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */
1623     OMX_U32 nPortIndex;               /**< port that this structure applies to */
1624     OMX_U8  nU8;                     /**< U8 value */
1625 } OMX_PARAM_U8TYPE;
1626
1627 typedef struct OMX_CONFIG_CAMERASETTINGSTYPE {
1628     OMX_U32 nSize;
1629     OMX_VERSIONTYPE nVersion;
1630     OMX_U32 nExposure;
1631     OMX_U32 nAnalogGain;
1632     OMX_U32 nDigitalGain;
1633     OMX_U32 nLux;
1634     OMX_U32 nRedGain;
1635     OMX_U32 nBlueGain;
1636     OMX_U32 nFocusPosition;
1637 } OMX_CONFIG_CAMERASETTINGSTYPE;
1638
1639 /* OMX_IndexConfigDrawBoxLineParams: Face box style parameters. */
1640 typedef struct OMX_YUVCOLOUR {
1641    OMX_U8 nY;
1642    OMX_U8 nU;
1643    OMX_U8 nV;
1644 } OMX_YUVCOLOUR;
1645
1646 typedef struct OMX_CONFIG_DRAWBOXLINEPARAMS {
1647     OMX_U32 nSize;                           /**< Size of this structure, in Bytes */
1648     OMX_VERSIONTYPE nVersion;                /**< OMX specification version information */
1649     OMX_U32 nPortIndex;                      /**< Port to which this config applies */
1650     OMX_U32 xCornerSize;                     /**< Size of the corners as a fraction of the complete side */
1651     OMX_U32 nPrimaryFaceLineWidth;           /**< Width of the box line for the primary face in pixels */
1652     OMX_U32 nOtherFaceLineWidth;             /**< Width of the box line for other faces in pixels */
1653     OMX_U32 nFocusRegionLineWidth;           /**< Width of the box line for focus regions in pixels */
1654     OMX_YUVCOLOUR sPrimaryFaceColour;        /**< YUV colour for the primary face */
1655     OMX_YUVCOLOUR sPrimaryFaceSmileColour;   /**< YUV colour for the primary face if smiling */
1656     OMX_YUVCOLOUR sPrimaryFaceBlinkColour;   /**< YUV colour for the primary face if blinking */
1657     OMX_YUVCOLOUR sOtherFaceColour;          /**< YUV colour for the all other faces */
1658     OMX_YUVCOLOUR sOtherFaceSmileColour;     /**< YUV colour for the all other faces if smiling */
1659     OMX_YUVCOLOUR sOtherFaceBlinkColour;     /**< YUV colour for the all other faces if blinking */
1660     OMX_BOOL bShowFocusRegionsWhenIdle;      /**< Are focus regions displayed when just in viewfinder/AF idle */
1661     OMX_YUVCOLOUR sFocusRegionColour;        /**< YUV colour for focus regions */
1662     OMX_BOOL bShowAfState;                   /**< Change to the colours specified below if AF cycle has run */
1663     OMX_BOOL bShowOnlyPrimaryAfState;        /**< Only show the primary face when displaying the AF status */
1664     OMX_BOOL bCombineNonFaceRegions;         /**< Combine all regions not defined as faces into one single box covering them all */
1665     OMX_YUVCOLOUR sAfLockPrimaryFaceColour;  /**< YUV colour for the primary face */
1666     OMX_YUVCOLOUR sAfLockOtherFaceColour;    /**< YUV colour for the all other faces */
1667     OMX_YUVCOLOUR sAfLockFocusRegionColour;  /**< YUV colour for focus regions */
1668     OMX_YUVCOLOUR sAfFailPrimaryFaceColour;  /**< YUV colour for the primary face */
1669     OMX_YUVCOLOUR sAfFailOtherFaceColour;    /**< YUV colour for the all other faces */
1670     OMX_YUVCOLOUR sAfFailFocusRegionColour;  /**< YUV colour for focus regions */
1671  } OMX_CONFIG_DRAWBOXLINEPARAMS;
1672 /*
1673 Query / set the parameters for the box to be drawn around faces/focus regions.
1674 */
1675
1676  #define OMX_PARAM_CAMERARMITYPE_RMINAME_LEN 16
1677  //OMX_IndexParamCameraRmiControl
1678  typedef struct OMX_PARAM_CAMERARMITYPE {
1679     OMX_U32 nSize;
1680     OMX_VERSIONTYPE nVersion;
1681     OMX_BOOL bEnabled;
1682     OMX_U8 sRmiName[OMX_PARAM_CAMERARMITYPE_RMINAME_LEN];
1683     OMX_U32 nInputBufferHeight;
1684     OMX_U32 nRmiBufferSize;
1685     OMX_BRCM_POOL_T *pImagePool;
1686  } OMX_PARAM_CAMERARMITYPE;
1687
1688 /* OMX_IndexConfigBrcmSyncOutput: Forcing a write sync */
1689 typedef struct OMX_CONFIG_BRCMSYNCOUTPUTTYPE {
1690     OMX_U32 nSize;                           /**< Size of this structure, in Bytes */
1691     OMX_VERSIONTYPE nVersion;                /**< OMX specification version information */
1692 }  OMX_CONFIG_BRCMSYNCOUTPUTTYPE;
1693 /*
1694 Setting this config forces a sync of data to the filesystem.
1695 */
1696
1697 /* OMX_IndexConfigDrmView: View information for DRM rental files */
1698 typedef struct OMX_CONFIG_DRMVIEWTYPE {
1699    OMX_U32 nSize;             /**< Size of this structure, in Bytes */
1700    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
1701    OMX_U32 nCurrentView;      /**< Current view count */
1702    OMX_U32 nMaxView;          /**< Max. no. of view allowed */
1703 } OMX_CONFIG_DRMVIEWTYPE;
1704 /*
1705 This structure contains information about the number of available
1706 views in the selected DRM rental file, which typically have a given
1707 maximum view count.  It allows the user to explicitly agree to playing
1708 the file, which will increment the number of current views the file
1709 has had.
1710 */
1711
1712 typedef struct OMX_PARAM_BRCMU64TYPE {
1713     OMX_U32 nSize;                    /**< Size of this structure, in Bytes */
1714     OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */
1715     OMX_U32 nPortIndex;               /**< port that this structure applies to */
1716     OMX_U32 nLowPart;                 /**< low bits of the unsigned 64 bit value */
1717     OMX_U32 nHighPart;                /**< high bits of the unsigned 64 bit value */
1718 } OMX_PARAM_BRCMU64TYPE;
1719
1720 /* OMX_IndexParamBrcmDisableEXIF: Disable generation of EXIF data */
1721 /*
1722 This parameter is used by clients to control the generation of exif
1723 data in JPEG images.
1724 */
1725
1726 /* OMX_IndexParamBrcmThumbnail: Control generation of thumbnail */
1727 typedef struct OMX_PARAM_BRCMTHUMBNAILTYPE {
1728     OMX_U32 nSize;                    /**< Size of this structure, in Bytes */
1729     OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */
1730     OMX_BOOL bEnable;                 /**< Enable generation of thumbnails during still capture */
1731     OMX_BOOL bUsePreview;             /**< Use the preview image (as is) as thumbnail */
1732     OMX_U32 nWidth;                   /**< Desired width of the thumbnail */
1733     OMX_U32 nHeight;                  /**< Desired height of the thumbnail */
1734 } OMX_PARAM_BRCMTHUMBNAILTYPE;
1735 /*
1736 This parameter is used by clients to control how thumbnails are
1737 generated when creating still images.
1738
1739 Thumbnail generation will be turned on or off depending on the
1740 \code{bEnable} field.
1741
1742 The \code{bUsePreview} field will let the component know whether it
1743 should use the low resolution preview image (if the component has one
1744 available) as is for the thumbnail. When this is set to true, it should
1745 make the generation of thumbnails faster (if a preview image is available)
1746 and should use less memory as well.
1747
1748 The \code{nWidth} and \code{nHeight} fields allow the client to
1749 specify the dimensions of the thumbnail.  If both \code{nWidth} and
1750 \code{nHeight} are 0, we will calculate a sensible size for the
1751 thumbnail.
1752 */
1753
1754 typedef struct OMX_PARAM_BRCMASPECTRATIOTYPE {
1755     OMX_U32 nSize;
1756     OMX_VERSIONTYPE nVersion;
1757     OMX_U32 nPortIndex;
1758     OMX_U32 nWidth;
1759     OMX_U32 nHeight;
1760 } OMX_PARAM_BRCMASPECTRATIOTYPE;
1761
1762 /* OMX_IndexParamBrcmVideoDecodeErrorConcealment: Control error concealment for video decode */
1763 typedef struct OMX_PARAM_BRCMVIDEODECODEERRORCONCEALMENTTYPE {
1764    OMX_U32 nSize;
1765    OMX_VERSIONTYPE nVersion;
1766    OMX_BOOL bStartWithValidFrame; /**< Decoder will only start emitting frames from a non-corrupted frame */
1767 } OMX_PARAM_BRCMVIDEODECODEERRORCONCEALMENTTYPE;
1768 /*
1769  This parameter is used by clients to control the type of error concealment
1770  that will be done by the video decoder.
1771  */
1772
1773 #define OMX_CONFIG_FLASHINFOTYPE_NAME_LEN 16
1774 typedef struct OMX_CONFIG_FLASHINFOTYPE
1775 {
1776    OMX_U32 nSize;
1777    OMX_VERSIONTYPE nVersion;
1778    OMX_U8 sFlashName[OMX_CONFIG_FLASHINFOTYPE_NAME_LEN];
1779    OMX_CAMERAFLASHTYPE eFlashType;
1780    OMX_U8 nDeviceId;
1781    OMX_U8 nDeviceVersion;
1782 } OMX_CONFIG_FLASHINFOTYPE;
1783
1784 /* OMX_IndexParamBrcmInterpolateMissingTimestamps: Configure component to interpolate missing timestamps */
1785 /*
1786 Configures a component so that it tries to timestamp all the buffers it outputs.
1787 If the timestamp information is missing from the original buffer, the
1788 component will try its best to interpolate a value for the missing timestamp.
1789  */
1790
1791 /* OMX_IndexParamBrcmSetCodecPerformanceMonitoring: Configure component to output performance statistics */
1792 /*
1793 Configures a codec component so that it outputs performance statistics to
1794 the given DECODE_PROGRESS_REPORT_T structure (passed as a pointer).
1795 This structure can then be read by the client to find out where the codec is
1796 at in its processing.
1797  */
1798
1799 /* OMX_IndexConfigDynamicRangeExpansion: Configure image dynamic range expansion processing */
1800 typedef enum OMX_DYNAMICRANGEEXPANSIONMODETYPE {
1801    OMX_DynRangeExpOff,
1802    OMX_DynRangeExpLow,
1803    OMX_DynRangeExpMedium,
1804    OMX_DynRangeExpHigh,
1805    OMX_DynRangeExpKhronosExtensions = 0x6F000000,
1806    OMX_DynRangeExpVendorStartUnused = 0x7F000000,
1807    OMX_DynRangeExpMax = 0x7FFFFFFF
1808 } OMX_DYNAMICRANGEEXPANSIONMODETYPE;
1809
1810 typedef struct OMX_CONFIG_DYNAMICRANGEEXPANSIONTYPE
1811 {
1812    OMX_U32 nSize;
1813    OMX_VERSIONTYPE nVersion;
1814    OMX_DYNAMICRANGEEXPANSIONMODETYPE eMode;
1815 } OMX_CONFIG_DYNAMICRANGEEXPANSIONTYPE;
1816 /*
1817 Configures the intensity of an image dynamic range expansion processing stage
1818 */
1819
1820 /* OMX_IndexParamBrcmTransposeBufferCount: Configure the number of pre-allocated transpose buffers  */
1821 /*
1822 This config allows the client to explicitly set the number of destination buffers pre-allocated for
1823 ports that support 90/270 degree rotation (e.g. in video_render). The buffers will be pre-allocated during
1824 a state transition from LOADED to IDLE (the transition will fail if there is not enough memory available
1825 for the buffers).
1826 .
1827 */
1828
1829
1830 /* OMX_IndexParamBrcmThreadAffinity: Control the CPU affinity of component thread(s) */
1831 typedef enum OMX_BRCMTHREADAFFINITYTYPE {
1832    OMX_BrcmThreadAffinityCPU0,
1833    OMX_BrcmThreadAffinityCPU1,
1834    OMX_BrcmThreadAffinityMax = 0x7FFFFFFF
1835 } OMX_BRCMTHREADAFFINITYTYPE;
1836
1837 typedef struct OMX_PARAM_BRCMTHREADAFFINITYTYPE {
1838    OMX_U32 nSize;
1839    OMX_VERSIONTYPE nVersion;
1840    OMX_BRCMTHREADAFFINITYTYPE eAffinity;  /**< Thread CPU affinity */
1841 } OMX_PARAM_BRCMTHREADAFFINITYTYPE;
1842 /*
1843  This parameter is used by clients to hint the CPU that a component thread should run on.
1844  */
1845
1846  /* OMX_IndexConfigCommonSceneDetected: Reports the scene type detected by a scene detection algorithm. */
1847 typedef enum OMX_SCENEDETECTTYPE {
1848    OMX_SceneDetectUnknown,
1849    OMX_SceneDetectLandscape,
1850    OMX_SceneDetectPortrait,
1851    OMX_SceneDetectMacro,
1852    OMX_SceneDetectNight,
1853    OMX_SceneDetectPortraitNight,
1854    OMX_SceneDetectBacklit,
1855    OMX_SceneDetectPortraitBacklit,
1856    OMX_SceneDetectSunset,
1857    OMX_SceneDetectBeach,
1858    OMX_SceneDetectSnow,
1859    OMX_SceneDetectFireworks,
1860    OMX_SceneDetectMax = 0x7FFFFFFF
1861 } OMX_SCENEDETECTTYPE;
1862
1863 /* OMX_IndexConfigCommonSceneDetected: Reports the scene type detected by a scene detection algorithm. */
1864 typedef struct OMX_CONFIG_SCENEDETECTTYPE {
1865    OMX_U32 nSize;
1866    OMX_VERSIONTYPE nVersion;
1867    OMX_SCENEDETECTTYPE eScene;  /**< Scene type detected */
1868 } OMX_CONFIG_SCENEDETECTTYPE;
1869 /*
1870  This config is used to report to clients the scene type that has been detected.
1871  */
1872
1873 /* OMX_IndexParamNalStreamFormat: Control the NAL unit packaging. This is a Khronos extension. */
1874 typedef enum OMX_INDEXEXTTYPE {
1875     /* Video parameters and configurations */
1876     OMX_IndexExtVideoStartUnused = OMX_IndexKhronosExtensions + 0x00600000,
1877     OMX_IndexParamNalStreamFormatSupported,         /**< reference: OMX_NALSTREAMFORMATTYPE */
1878     OMX_IndexParamNalStreamFormat,                  /**< reference: OMX_NALSTREAMFORMATTYPE */
1879     OMX_IndexParamNalStreamFormatSelect,            /**< reference: OMX_NALSTREAMFORMATTYPE */
1880
1881     OMX_IndexExtMax = 0x7FFFFFFF
1882 } OMX_INDEXEXTTYPE;
1883
1884 /* OMX_IndexParamNalStreamFormat: Control the NAL unit packaging. This is a Khronos extension. */
1885 typedef enum OMX_NALUFORMATSTYPE {
1886     OMX_NaluFormatStartCodes = 1,
1887     OMX_NaluFormatOneNaluPerBuffer = 2,
1888     OMX_NaluFormatOneByteInterleaveLength = 4,
1889     OMX_NaluFormatTwoByteInterleaveLength = 8,
1890     OMX_NaluFormatFourByteInterleaveLength = 16,
1891     OMX_NaluFormatCodingMax = 0x7FFFFFFF
1892 } OMX_NALUFORMATSTYPE;
1893
1894 /* OMX_IndexParamNalStreamFormat: Control the NAL unit packaging. This is a Khronos extension. */
1895 typedef struct OMX_NALSTREAMFORMATTYPE{
1896     OMX_U32 nSize;
1897     OMX_VERSIONTYPE nVersion;
1898     OMX_U32 nPortIndex;
1899     OMX_NALUFORMATSTYPE eNaluFormat;
1900 } OMX_NALSTREAMFORMATTYPE;
1901 /*
1902  This parameter is used to control the NAL unit packaging of an H264 video port.
1903  */
1904
1905 /* OMX_IndexParamVideoMvc: MVC codec parameters */
1906 typedef  struct OMX_VIDEO_PARAM_AVCTYPE  OMX_VIDEO_PARAM_MVCTYPE;
1907 /*
1908 This parameter is currently identical to the AVC parameter type.
1909 */
1910
1911  /* OMX_IndexConfigBrcmDrawStaticBox: Define static box to be drawn */
1912 typedef enum OMX_STATICBOXTYPE {
1913    OMX_StaticBoxNormal,
1914    OMX_StaticBoxPrimaryFaceAfIdle,
1915    OMX_StaticBoxNonPrimaryFaceAfIdle,
1916    OMX_StaticBoxFocusRegionAfIdle,
1917    OMX_StaticBoxPrimaryFaceAfSuccess,
1918    OMX_StaticBoxNonPrimaryFaceAfSuccess,
1919    OMX_StaticBoxFocusRegionAfSuccess,
1920    OMX_StaticBoxPrimaryFaceAfFail,
1921    OMX_StaticBoxNonPrimaryFaceAfFail,
1922    OMX_StaticBoxFocusRegionAfFail,
1923    OMX_StaticBoxMax
1924 } OMX_STATICBOXTYPE;
1925
1926 typedef struct OMX_STATICBOX {
1927    OMX_U32 xLeft;
1928    OMX_U32 xTop;
1929    OMX_U32 xWidth;
1930    OMX_U32 xHeight;
1931    OMX_STATICBOXTYPE eType;
1932 } OMX_STATICBOX;
1933
1934 typedef struct OMX_CONFIG_STATICBOXTYPE
1935 {
1936    OMX_U32 nSize;
1937    OMX_VERSIONTYPE nVersion;
1938    OMX_U32 nPortIndex;
1939    OMX_U32 nIndex;
1940    OMX_U32 nTotalBoxes;
1941    OMX_S32 nValidBoxes;
1942    OMX_BOOL bDrawOtherBoxes;
1943    OMX_STATICBOX sBoxes[1];
1944 } OMX_CONFIG_STATICBOXTYPE;
1945 /*
1946 Query / set the parameters for a box to always be drawn on viewfinder images
1947 The x/y/width/height values for the boxes are relative to the overall image.
1948
1949 \code{nIndex} - first box number being set/read, allowing retrieval/setting
1950 of many boxes over several requests.
1951
1952 \code{nValidBoxes} - total number of boxes currently defined.
1953
1954 \code{nValidBoxes} - number of valid boxes in the \code{sBoxes} array.
1955 When getting, the client sets this to the number of boxes available.
1956 The component writes box data and updates this field with how many
1957 boxes have been written to.
1958 When setting, this is the number of boxes defined with this structure
1959
1960 \code{sBoxes} - variable length array of static boxes.
1961 */
1962
1963 /* OMX_IndexConfigPortCapturing: Per-port capturing state */
1964 typedef struct OMX_CONFIG_PORTBOOLEANTYPE{
1965     OMX_U32 nSize;
1966     OMX_VERSIONTYPE nVersion;
1967     OMX_U32 nPortIndex;
1968     OMX_BOOL bEnabled;
1969 } OMX_CONFIG_PORTBOOLEANTYPE;
1970 /*
1971 This is proposed in IL533f for controlling
1972 which ports of a multi-port camera component are capturing frames.
1973 */
1974
1975 /* OMX_IndexConfigCaptureMode: Capturing mode type */
1976 typedef enum OMX_CAMERACAPTUREMODETYPE {
1977    OMX_CameraCaptureModeWaitForCaptureEnd,
1978    OMX_CameraCaptureModeWaitForCaptureEndAndUsePreviousInputImage,
1979    OMX_CameraCaptureModeResumeViewfinderImmediately,
1980    OMX_CameraCaptureModeMax,
1981 } OMX_CAMERACAPTUREMODETYPE;
1982
1983 typedef struct OMX_PARAM_CAMERACAPTUREMODETYPE{
1984     OMX_U32 nSize;
1985     OMX_VERSIONTYPE nVersion;
1986     OMX_U32 nPortIndex;
1987     OMX_CAMERACAPTUREMODETYPE eMode;
1988 } OMX_PARAM_CAMERACAPTUREMODETYPE;
1989 /*
1990 This controls the mode of operation for
1991 still image capture in the camera component.
1992 */
1993
1994 /* OMX_IndexParamBrcmDrmEncryption: Set DRM encryption scheme */
1995 typedef enum OMX_BRCMDRMENCRYPTIONTYPE
1996 {
1997    OMX_DrmEncryptionNone = 0,
1998    OMX_DrmEncryptionHdcp2,
1999    OMX_DrmEncryptionKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
2000    OMX_DrmEncryptionVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
2001    OMX_DrmEncryptionRangeMax = 0x7FFFFFFF
2002 } OMX_BRCMDRMENCRYPTIONTYPE;
2003
2004 typedef struct OMX_PARAM_BRCMDRMENCRYPTIONTYPE
2005 {
2006    OMX_U32 nSize;
2007    OMX_VERSIONTYPE nVersion;
2008    OMX_U32 nPortIndex;
2009    OMX_BRCMDRMENCRYPTIONTYPE eEncryption;
2010    OMX_U32 nConfigDataLen;
2011    OMX_U8 configData[1];
2012 } OMX_PARAM_BRCMDRMENCRYPTIONTYPE;
2013 /*
2014 Query/set the DRM encryption scheme used by a port writing out data.
2015 */
2016
2017
2018 /* OMX_IndexConfigBufferStall: Advertise buffer stall state */
2019 typedef struct OMX_CONFIG_BUFFERSTALLTYPE
2020 {
2021    OMX_U32 nSize;
2022    OMX_VERSIONTYPE nVersion;
2023    OMX_U32 nPortIndex;
2024    OMX_BOOL bStalled;      /**< Whether we are stalled */
2025    OMX_U32 nDelay;         /**< Delay in real time (us) from last buffer to current time */
2026 } OMX_CONFIG_BUFFERSTALLTYPE;
2027 /*
2028 Query/set the buffer stall threashold.  When set the \code{nDelay}
2029 parameter specifies a time to class whether buffer output is stalled.
2030 When get, the \code{nDelay} parameter indicates the current buffer
2031 delay, and the {bStalled} parameter indicates whether this time is
2032 over a previously set threashold.  When
2033 \code{OMX_IndexConfigRequestCallback} is used with this index, a
2034 notification is given when \code{bStalled} changes.
2035 */
2036
2037 /* OMX_IndexConfigLatencyTarget: Maintain target latency by adjusting clock speed */
2038 typedef struct OMX_CONFIG_LATENCYTARGETTYPE
2039 {
2040    OMX_U32 nSize;
2041    OMX_VERSIONTYPE nVersion;
2042    OMX_U32 nPortIndex;
2043    OMX_BOOL bEnabled; /**< whether this mode is enabled */
2044    OMX_U32 nFilter; /**< number of latency samples to filter on, good value: 1 */
2045    OMX_U32 nTarget; /**< target latency, us */
2046    OMX_U32 nShift;  /**< shift for storing latency values, good value: 7 */
2047    OMX_S32 nSpeedFactor; /**< multiplier for speed changes, in 24.8 format, good value: 256-512 */
2048    OMX_S32 nInterFactor; /**< divider for comparing latency versus gradiant, good value: 300 */
2049    OMX_S32 nAdjCap; /**< limit for speed change before nSpeedFactor is applied, good value: 100 */
2050 } OMX_CONFIG_LATENCYTARGETTYPE;
2051 /*
2052 Query/set parameters used when adjusting clock speed to match the
2053 measured latency to a specified value.
2054 */
2055
2056 /* OMX_IndexConfigBrcmUseProprietaryCallback: Force use of proprietary callback */
2057 typedef struct OMX_CONFIG_BRCMUSEPROPRIETARYCALLBACKTYPE
2058 {
2059    OMX_U32 nSize;
2060    OMX_VERSIONTYPE nVersion;
2061    OMX_U32 nPortIndex;
2062    OMX_BOOL bEnable;
2063 } OMX_CONFIG_BRCMUSEPROPRIETARYCALLBACKTYPE;
2064 /*
2065 Disable/enable the use of proprietary callbacks rather than OpenMAX IL buffer handling.
2066 */
2067
2068 /* OMX_IndexParamCommonUseStcTimestamps: Select timestamp mode */
2069 typedef enum OMX_TIMESTAMPMODETYPE
2070 {
2071    OMX_TimestampModeZero = 0,       /**< Use a timestamp of 0 */
2072    OMX_TimestampModeRawStc,         /**< Use the raw STC as the timestamp */
2073    OMX_TimestampModeResetStc,       /**< Store the STC when video capture port goes active, and subtract that from STC for the timestamp */
2074    OMX_TimestampModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
2075    OMX_TimestampModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
2076    OMX_TimestampModeMax = 0x7FFFFFFF
2077 } OMX_TIMESTAMPMODETYPE;
2078
2079 typedef struct OMX_PARAM_TIMESTAMPMODETYPE
2080 {
2081    OMX_U32 nSize;
2082    OMX_VERSIONTYPE nVersion;
2083    OMX_TIMESTAMPMODETYPE eTimestampMode;
2084 } OMX_PARAM_TIMESTAMPMODETYPE;
2085 /*
2086  Specifies what to use as timestamps in the abscence of a clock component.
2087 */
2088
2089 /* EGL image buffer for passing to video port.
2090  * Used when port color format is OMX_COLOR_FormatBRCMEGL.
2091  */
2092 typedef struct OMX_BRCMVEGLIMAGETYPE
2093 {
2094    /* Passed between ARM + VC; use fixed width types. */
2095    OMX_U32 nWidth;
2096    OMX_U32 nHeight;
2097    OMX_U32 nStride;
2098    OMX_U32 nUmemHandle;
2099    OMX_U32 nUmemOffset;
2100    OMX_U32 nFlipped;    /* Non-zero -> vertically flipped image */
2101 } OMX_BRCMVEGLIMAGETYPE;
2102
2103 /* Provides field of view 
2104  */
2105 typedef struct OMX_CONFIG_BRCMFOVTYPE
2106 {
2107    OMX_U32 nSize;
2108    OMX_VERSIONTYPE nVersion;
2109    OMX_U32 nPortIndex;
2110    OMX_U32 xFieldOfViewHorizontal;  /**< Horizontal field of view in degrees. 16p16 value */
2111    OMX_U32 xFieldOfViewVertical;    /**< Vertical field of view in degrees. 16p16 value */
2112 } OMX_CONFIG_BRCMFOVTYPE;
2113
2114 /* OMX_IndexConfigBrcmDecoderPassThrough: Enabling Audio Passthrough */
2115 /*
2116 This allows an audio decoder to disable decoding the stream and pass through correctly framed
2117 data to enable playback of compressed audio to supported output devices.
2118 */
2119
2120 /* OMX_IndexConfigBrcmClockReferenceSource: Select Clock Reference Source */
2121 /*
2122 This control allows communicating directly to an audio renderer component whether it should
2123 act as a clock reference source or act as a slave.
2124 */
2125
2126 /* OMX_IndexConfigEncLevelExtension: AVC Override encode capabilities */
2127 typedef struct OMX_VIDEO_CONFIG_LEVEL_EXTEND {
2128    OMX_U32 nSize; 
2129    OMX_VERSIONTYPE nVersion;
2130    OMX_U32 nPortIndex;
2131    OMX_U32 nCustomMaxMBPS;     /**< Specifies maximum macro-blocks per second */
2132    OMX_U32 nCustomMaxFS;       /**< Specifies maximum frame size (macro-blocks per frame) */
2133    OMX_U32 nCustomMaxBRandCPB; /**< Specifies maximum bitrate in units of 1000 bits/s and Codec Picture Buffer (CPB derived from bitrate) */
2134 } OMX_VIDEO_CONFIG_LEVEL_EXTEND;
2135 /*
2136 This allows finer control of the H264 encode internal parameters.
2137 */
2138
2139 /* OMX_IndexParamBrcmEEDEEnable: Enable/Disable end to end distortion estimator */
2140 typedef struct OMX_VIDEO_EEDE_ENABLE {
2141     OMX_U32 nSize;
2142     OMX_VERSIONTYPE nVersion;
2143     OMX_U32 nPortIndex;
2144     OMX_U32 enable;
2145 } OMX_VIDEO_EEDE_ENABLE;
2146 /*
2147 This enables or disables the use of end to end distortion estimation.
2148 */
2149
2150 /* OMX_IndexParamBrcmEEDELossRate: Loss rate configuration for end to end distortion */
2151 typedef struct OMX_VIDEO_EEDE_LOSSRATE {
2152     OMX_U32 nSize;
2153     OMX_VERSIONTYPE nVersion;
2154     OMX_U32 nPortIndex;
2155    OMX_U32 loss_rate; /**< loss rate, 5 means 5% */
2156 } OMX_VIDEO_EEDE_LOSSRATE;
2157 /*
2158 Set the packet loss rate used by the end to end distortion estimator.
2159 */
2160
2161 /* OMX_IndexParamColorSpace: Colour space information */
2162 typedef enum OMX_COLORSPACETYPE
2163 {
2164    OMX_COLORSPACE_UNKNOWN,
2165    OMX_COLORSPACE_JPEG_JFIF,
2166    OMX_COLORSPACE_ITU_R_BT601,
2167    OMX_COLORSPACE_ITU_R_BT709,
2168    OMX_COLORSPACE_FCC,
2169    OMX_COLORSPACE_SMPTE240M,
2170    OMX_COLORSPACE_BT470_2_M,
2171    OMX_COLORSPACE_BT470_2_BG,
2172    OMX_COLORSPACE_JFIF_Y16_255,
2173    OMX_COLORSPACE_MAX = 0x7FFFFFFF
2174 } OMX_COLORSPACETYPE;
2175
2176 typedef struct OMX_PARAM_COLORSPACETYPE
2177 {
2178    OMX_U32 nSize;
2179    OMX_VERSIONTYPE nVersion;
2180    OMX_U32 nPortIndex;
2181    OMX_COLORSPACETYPE eColorSpace;
2182 } OMX_PARAM_COLORSPACETYPE;
2183
2184 typedef enum OMX_CAPTURESTATETYPE
2185 {
2186    OMX_NotCapturing,
2187    OMX_CaptureStarted,
2188    OMX_CaptureComplete,
2189    OMX_CaptureMax = 0x7FFFFFFF
2190 } OMX_CAPTURESTATETYPE;
2191
2192 typedef struct OMX_PARAM_CAPTURESTATETYPE
2193 {
2194    OMX_U32 nSize;
2195    OMX_VERSIONTYPE nVersion;
2196    OMX_U32 nPortIndex;
2197    OMX_CAPTURESTATETYPE eCaptureState;
2198 } OMX_PARAM_CAPTURESTATETYPE;
2199
2200 /*
2201 Provides information on the colour space that's in use during image/video processing.
2202 */
2203
2204 /* OMX_IndexConfigMinimiseFragmentation: Minimising Fragmentation */
2205 /*
2206 This control can be supported to enable the client to request that the component works
2207 to minimise fragmentation of output buffers.
2208 */
2209
2210 /* OMX_IndexConfigBrcmBufferFlagFilter: Filters buffers based on flags */
2211 /*
2212 This control can be set to request that buffers are conditionally forwarded on 
2213 output ports based on matching flags set on that buffer.
2214 */
2215
2216 /* OMX_IndexParamPortMaxFrameSize: Specifying maximum frame size */
2217 /*
2218 This control can be used to control the maximum frame size allowed on an output port.
2219 */
2220
2221 /* OMX_IndexConfigBrcmCameraRnDPreprocess: Enable use of development ISP software stage */
2222 /*
2223 This control can be used to enable a developmental software stage to be inserted into
2224 the preprocessor stage of the ISP.
2225 */
2226
2227 /* OMX_IndexConfigBrcmCameraRnDPostprocess: Enable use of development ISP software stage */
2228 /*
2229 This control can be used to enable a developmental software stage to be inserted into
2230 the postprocessor stage of the ISP.
2231 */
2232
2233 /* OMX_IndexParamDisableVllPool: Controlling use of memory for loadable modules */
2234 /*
2235 This control can be used to control whether loadable modules used a dedicated memory
2236 pool or use heap allocated memory.
2237 */
2238
2239 typedef struct OMX_PARAM_BRCMCONFIGFILETYPE {
2240    OMX_U32 nSize;                      /**< size of the structure in bytes, including
2241                                             actual URI name */
2242    OMX_VERSIONTYPE nVersion;           /**< OMX specification version information */
2243    OMX_U32 fileSize;                   /**< Size of complete file data */
2244 } OMX_PARAM_BRCMCONFIGFILETYPE;
2245
2246 typedef struct OMX_PARAM_BRCMCONFIGFILECHUNKTYPE {
2247    OMX_U32 nSize;                      /**< size of the structure in bytes, including
2248                                             actual chunk data */
2249    OMX_VERSIONTYPE nVersion;           /**< OMX specification version information */
2250    OMX_U32 size;                       /**< Number of bytes being transferred in this chunk */
2251    OMX_U32 offset;                     /**< Offset of this chunk in the file */
2252    OMX_U8 data[1];                     /**< Chunk data */
2253 } OMX_PARAM_BRCMCONFIGFILECHUNKTYPE;
2254
2255 typedef struct OMX_PARAM_BRCMFRAMERATERANGETYPE {
2256    OMX_U32 nSize;                      /**< size of the structure in bytes, including
2257                                             actual chunk data */
2258    OMX_VERSIONTYPE nVersion;           /**< OMX specification version information */
2259    OMX_U32 nPortIndex;
2260    OMX_U32 xFramerateLow;              /**< Low end of framerate range. Q16 format */
2261    OMX_U32 xFramerateHigh;             /**< High end of framerate range. Q16 format */
2262 } OMX_PARAM_BRCMFRAMERATERANGETYPE;
2263
2264 typedef struct OMX_PARAM_S32TYPE {
2265     OMX_U32 nSize;                    /**< Size of this structure, in Bytes */
2266     OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */
2267     OMX_U32 nPortIndex;               /**< port that this structure applies to */
2268     OMX_S32 nS32;                     /**< S32 value */
2269 } OMX_PARAM_S32TYPE;
2270
2271 typedef struct OMX_PARAM_BRCMVIDEODRMPROTECTBUFFERTYPE
2272 {
2273    OMX_U32 nSize;
2274    OMX_VERSIONTYPE nVersion;
2275
2276    OMX_U32 size_wanted;     /**< Input. Zero size means internal video decoder buffer,
2277                                  mem_handle and phys_addr not returned in this case */
2278    OMX_U32 protect;         /**< Input. 1 = protect, 0 = unprotect */
2279
2280    OMX_U32 mem_handle;      /**< Output. Handle for protected buffer */
2281    OMX_PTR phys_addr;       /**< Output. Physical memory address of protected buffer */
2282 } OMX_PARAM_BRCMVIDEODRMPROTECTBUFFERTYPE;
2283
2284 typedef struct OMX_CONFIG_ZEROSHUTTERLAGTYPE
2285 {
2286    OMX_U32 nSize;
2287    OMX_VERSIONTYPE nVersion;
2288
2289    OMX_U32 bZeroShutterMode;        /**< Select ZSL mode from the camera. */
2290    OMX_U32 bConcurrentCapture;      /**< Perform concurrent captures for full ZSL. */
2291
2292 } OMX_CONFIG_ZEROSHUTTERLAGTYPE;
2293
2294 typedef struct OMX_PARAM_BRCMVIDEODECODECONFIGVD3TYPE {
2295    OMX_U32 nSize;                      /**< size of the structure in bytes, including
2296                                             configuration data */
2297    OMX_VERSIONTYPE nVersion;           /**< OMX specification version information */
2298    OMX_U8 config[1];                   /**< Configuration data (a VD3_CONFIGURE_T) */
2299 } OMX_PARAM_BRCMVIDEODECODECONFIGVD3TYPE;
2300
2301 #endif
2302 /* File EOF */