1 /*--------------------------------------------------------------------------
2 Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are met:
6 * Redistributions of source code must retain the above copyright
7 notice, this list of conditions and the following disclaimer.
8 * Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 * Neither the name of The Linux Foundation nor
12 the names of its contributors may be used to endorse or promote
13 products derived from this software without specific prior written
14 permission.
15
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
26 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 --------------------------------------------------------------------------*/
28 #include "omx_video_encoder.h"
29 #include <string.h>
30 #include <stdio.h>
31 #ifdef _ANDROID_ICS_
32 #include <media/hardware/HardwareAPI.h>
33 #endif
34 #ifdef _ANDROID_
35 #include <cutils/properties.h>
36 #endif
37 #ifndef _ANDROID_
38 #include <glib.h>
39 #define strlcpy g_strlcpy
40 #endif
41 /*----------------------------------------------------------------------------
42 * Preprocessor Definitions and Constants
43 * -------------------------------------------------------------------------*/
44
45 #define OMX_SPEC_VERSION 0x00000101
46 #define OMX_INIT_STRUCT(_s_, _name_) \
47 memset((_s_), 0x0, sizeof(_name_)); \
48 (_s_)->nSize = sizeof(_name_); \
49 (_s_)->nVersion.nVersion = OMX_SPEC_VERSION
50
51 extern int m_pipe;
52 static int bframes;
53 static int entropy;
54 static int perfmode;
55 static int hybrid_hp;
56 // factory function executed by the core to create instances
get_omx_component_factory_fn(void)57 void *get_omx_component_factory_fn(void)
58 {
59 return(new omx_venc);
60 }
61
62 //constructor
63
omx_venc()64 omx_venc::omx_venc()
65 {
66 #ifdef _ANDROID_ICS_
67 meta_mode_enable = false;
68 memset(meta_buffer_hdr,0,sizeof(meta_buffer_hdr));
69 memset(meta_buffers,0,sizeof(meta_buffers));
70 memset(opaque_buffer_hdr,0,sizeof(opaque_buffer_hdr));
71 mUseProxyColorFormat = false;
72 get_syntaxhdr_enable = false;
73 #endif
74 bframes = entropy = 0;
75 char property_value[PROPERTY_VALUE_MAX] = {0};
76 property_get("vidc.debug.level", property_value, "1");
77 debug_level = atoi(property_value);
78 property_value[0] = '\0';
79 property_get("vidc.debug.bframes", property_value, "0");
80 bframes = atoi(property_value);
81 property_value[0] = '\0';
82 property_get("vidc.debug.entropy", property_value, "1");
83 entropy = !!atoi(property_value);
84 property_value[0] = '\0';
85 property_get("vidc.debug.perf.mode", property_value, "0");
86 perfmode = atoi(property_value);
87 property_value[0] = '\0';
88 property_get("vidc.debug.hybrid.hierp", property_value, "0");
89 hybrid_hp = atoi(property_value);
90 property_value[0] = '\0';
91 handle = NULL;
92 }
93
~omx_venc()94 omx_venc::~omx_venc()
95 {
96 get_syntaxhdr_enable = false;
97 //nothing to do
98 }
99
100 /* ======================================================================
101 FUNCTION
102 omx_venc::ComponentInit
103
104 DESCRIPTION
105 Initialize the component.
106
107 PARAMETERS
108 ctxt -- Context information related to the self.
109 id -- Event identifier. This could be any of the following:
110 1. Command completion event
111 2. Buffer done callback event
112 3. Frame done callback event
113
114 RETURN VALUE
115 None.
116
117 ========================================================================== */
component_init(OMX_STRING role)118 OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
119 {
120
121 OMX_ERRORTYPE eRet = OMX_ErrorNone;
122
123 int fds[2];
124 int r;
125
126 OMX_VIDEO_CODINGTYPE codec_type;
127
128 DEBUG_PRINT_HIGH("omx_venc(): Inside component_init()");
129 // Copy the role information which provides the decoder m_nkind
130 strlcpy((char *)m_nkind,role,OMX_MAX_STRINGNAME_SIZE);
131 secure_session = false;
132
133 if (!strncmp((char *)m_nkind,"OMX.qcom.video.encoder.mpeg4",\
134 OMX_MAX_STRINGNAME_SIZE)) {
135 strlcpy((char *)m_cRole, "video_encoder.mpeg4",\
136 OMX_MAX_STRINGNAME_SIZE);
137 codec_type = OMX_VIDEO_CodingMPEG4;
138 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\
139 OMX_MAX_STRINGNAME_SIZE)) {
140 strlcpy((char *)m_cRole, "video_encoder.h263",OMX_MAX_STRINGNAME_SIZE);
141 codec_type = OMX_VIDEO_CodingH263;
142 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
143 OMX_MAX_STRINGNAME_SIZE)) {
144 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
145 codec_type = OMX_VIDEO_CodingAVC;
146 } else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
147 OMX_MAX_STRINGNAME_SIZE)) {
148 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
149 codec_type = OMX_VIDEO_CodingAVC;
150 secure_session = true;
151 }
152 #ifdef _MSM8974_
153 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.vp8", \
154 OMX_MAX_STRINGNAME_SIZE)) {
155 strlcpy((char *)m_cRole, "video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE);
156 codec_type = OMX_VIDEO_CodingVP8;
157 }
158 #endif
159 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc", \
160 OMX_MAX_STRINGNAME_SIZE)) {
161 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
162 codec_type = OMX_VIDEO_CodingHEVC;
163 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc.secure", \
164 OMX_MAX_STRINGNAME_SIZE)) {
165 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
166 codec_type = OMX_VIDEO_CodingHEVC;
167 secure_session = true;
168 } else {
169 DEBUG_PRINT_ERROR("ERROR: Unknown Component");
170 eRet = OMX_ErrorInvalidComponentName;
171 }
172
173
174 if (eRet != OMX_ErrorNone) {
175 return eRet;
176 }
177 #ifdef ENABLE_GET_SYNTAX_HDR
178 get_syntaxhdr_enable = true;
179 DEBUG_PRINT_HIGH("Get syntax header enabled");
180 #endif
181
182 handle = new venc_dev(this);
183
184 if (handle == NULL) {
185 DEBUG_PRINT_ERROR("ERROR: handle is NULL");
186 return OMX_ErrorInsufficientResources;
187 }
188
189 if (handle->venc_open(codec_type) != true) {
190 DEBUG_PRINT_ERROR("ERROR: venc_open failed");
191 eRet = OMX_ErrorInsufficientResources;
192 goto init_error;
193 }
194
195 //Intialise the OMX layer variables
196 memset(&m_pCallbacks,0,sizeof(OMX_CALLBACKTYPE));
197
198 OMX_INIT_STRUCT(&m_sPortParam, OMX_PORT_PARAM_TYPE);
199 m_sPortParam.nPorts = 0x2;
200 m_sPortParam.nStartPortNumber = (OMX_U32) PORT_INDEX_IN;
201
202 OMX_INIT_STRUCT(&m_sPortParam_audio, OMX_PORT_PARAM_TYPE);
203 m_sPortParam_audio.nPorts = 0;
204 m_sPortParam_audio.nStartPortNumber = 0;
205
206 OMX_INIT_STRUCT(&m_sPortParam_img, OMX_PORT_PARAM_TYPE);
207 m_sPortParam_img.nPorts = 0;
208 m_sPortParam_img.nStartPortNumber = 0;
209
210 OMX_INIT_STRUCT(&m_sParamBitrate, OMX_VIDEO_PARAM_BITRATETYPE);
211 m_sParamBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
212 m_sParamBitrate.eControlRate = OMX_Video_ControlRateVariableSkipFrames;
213 m_sParamBitrate.nTargetBitrate = 64000;
214
215 OMX_INIT_STRUCT(&m_sConfigBitrate, OMX_VIDEO_CONFIG_BITRATETYPE);
216 m_sConfigBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
217 m_sConfigBitrate.nEncodeBitrate = 64000;
218
219 OMX_INIT_STRUCT(&m_sConfigFramerate, OMX_CONFIG_FRAMERATETYPE);
220 m_sConfigFramerate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
221 m_sConfigFramerate.xEncodeFramerate = 30 << 16;
222
223 OMX_INIT_STRUCT(&m_sConfigIntraRefreshVOP, OMX_CONFIG_INTRAREFRESHVOPTYPE);
224 m_sConfigIntraRefreshVOP.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
225 m_sConfigIntraRefreshVOP.IntraRefreshVOP = OMX_FALSE;
226
227 OMX_INIT_STRUCT(&m_sConfigFrameRotation, OMX_CONFIG_ROTATIONTYPE);
228 m_sConfigFrameRotation.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
229 m_sConfigFrameRotation.nRotation = 0;
230
231 OMX_INIT_STRUCT(&m_sSessionQuantization, OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
232 m_sSessionQuantization.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
233 m_sSessionQuantization.nQpI = 9;
234 m_sSessionQuantization.nQpP = 6;
235 m_sSessionQuantization.nQpB = 2;
236
237 OMX_INIT_STRUCT(&m_sSessionQPRange, OMX_QCOM_VIDEO_PARAM_QPRANGETYPE);
238 m_sSessionQPRange.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
239 m_sSessionQPRange.minQP = 2;
240 if (codec_type == OMX_VIDEO_CodingAVC)
241 m_sSessionQPRange.maxQP = 51;
242 else
243 m_sSessionQPRange.maxQP = 31;
244
245 OMX_INIT_STRUCT(&m_sAVCSliceFMO, OMX_VIDEO_PARAM_AVCSLICEFMO);
246 m_sAVCSliceFMO.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
247 m_sAVCSliceFMO.eSliceMode = OMX_VIDEO_SLICEMODE_AVCDefault;
248 m_sAVCSliceFMO.nNumSliceGroups = 0;
249 m_sAVCSliceFMO.nSliceGroupMapType = 0;
250 OMX_INIT_STRUCT(&m_sParamProfileLevel, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
251 m_sParamProfileLevel.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
252
253 OMX_INIT_STRUCT(&m_sIntraperiod, QOMX_VIDEO_INTRAPERIODTYPE);
254 m_sIntraperiod.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
255 m_sIntraperiod.nPFrames = (m_sConfigFramerate.xEncodeFramerate * 2) - 1;
256
257 OMX_INIT_STRUCT(&m_sErrorCorrection, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
258 m_sErrorCorrection.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
259 m_sErrorCorrection.bEnableDataPartitioning = OMX_FALSE;
260 m_sErrorCorrection.bEnableHEC = OMX_FALSE;
261 m_sErrorCorrection.bEnableResync = OMX_FALSE;
262 m_sErrorCorrection.bEnableRVLC = OMX_FALSE;
263 m_sErrorCorrection.nResynchMarkerSpacing = 0;
264
265 OMX_INIT_STRUCT(&m_sIntraRefresh, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
266 m_sIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
267 m_sIntraRefresh.eRefreshMode = OMX_VIDEO_IntraRefreshMax;
268
269 OMX_INIT_STRUCT(&m_sConfigIntraRefresh, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE);
270 m_sConfigIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
271 m_sConfigIntraRefresh.nRefreshPeriod = 0;
272
273 if (codec_type == OMX_VIDEO_CodingMPEG4) {
274 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_MPEG4ProfileSimple;
275 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_MPEG4Level0;
276 } else if (codec_type == OMX_VIDEO_CodingH263) {
277 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_H263ProfileBaseline;
278 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_H263Level10;
279 } else if (codec_type == OMX_VIDEO_CodingAVC) {
280 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_AVCProfileBaseline;
281 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_AVCLevel1;
282 } else if (codec_type == OMX_VIDEO_CodingVP8) {
283 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_VP8ProfileMain;
284 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_VP8Level_Version0;
285 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
286 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_HEVCProfileMain;
287 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_HEVCMainTierLevel1;
288 }
289
290 // Initialize the video parameters for input port
291 OMX_INIT_STRUCT(&m_sInPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
292 m_sInPortDef.nPortIndex= (OMX_U32) PORT_INDEX_IN;
293 m_sInPortDef.bEnabled = OMX_TRUE;
294 m_sInPortDef.bPopulated = OMX_FALSE;
295 m_sInPortDef.eDomain = OMX_PortDomainVideo;
296 m_sInPortDef.eDir = OMX_DirInput;
297 m_sInPortDef.format.video.cMIMEType = (char *)"YUV420";
298 m_sInPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH;
299 m_sInPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT;
300 m_sInPortDef.format.video.nStride = OMX_CORE_QCIF_WIDTH;
301 m_sInPortDef.format.video.nSliceHeight = OMX_CORE_QCIF_HEIGHT;
302 m_sInPortDef.format.video.nBitrate = 64000;
303 m_sInPortDef.format.video.xFramerate = 15 << 16;
304 m_sInPortDef.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)
305 QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m;
306 m_sInPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
307
308 if (dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
309 &m_sInPortDef.nBufferCountActual,
310 &m_sInPortDef.nBufferSize,
311 m_sInPortDef.nPortIndex) != true) {
312 eRet = OMX_ErrorUndefined;
313 goto init_error;
314 }
315
316 // Initialize the video parameters for output port
317 OMX_INIT_STRUCT(&m_sOutPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
318 m_sOutPortDef.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
319 m_sOutPortDef.bEnabled = OMX_TRUE;
320 m_sOutPortDef.bPopulated = OMX_FALSE;
321 m_sOutPortDef.eDomain = OMX_PortDomainVideo;
322 m_sOutPortDef.eDir = OMX_DirOutput;
323 m_sOutPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH;
324 m_sOutPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT;
325 m_sOutPortDef.format.video.nBitrate = 64000;
326 m_sOutPortDef.format.video.xFramerate = 15 << 16;
327 m_sOutPortDef.format.video.eColorFormat = OMX_COLOR_FormatUnused;
328 if (codec_type == OMX_VIDEO_CodingMPEG4) {
329 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
330 } else if (codec_type == OMX_VIDEO_CodingH263) {
331 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
332 } else if (codec_type == OMX_VIDEO_CodingAVC) {
333 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
334 } else if (codec_type == OMX_VIDEO_CodingVP8) {
335 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingVP8;
336 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
337 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
338 }
339
340 if (dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
341 &m_sOutPortDef.nBufferCountActual,
342 &m_sOutPortDef.nBufferSize,
343 m_sOutPortDef.nPortIndex) != true) {
344 eRet = OMX_ErrorUndefined;
345 }
346
347 // Initialize the video color format for input port
348 OMX_INIT_STRUCT(&m_sInPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
349 m_sInPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_IN;
350 m_sInPortFormat.nIndex = 0;
351 m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE)
352 QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m;
353 m_sInPortFormat.eCompressionFormat = OMX_VIDEO_CodingUnused;
354
355
356 // Initialize the compression format for output port
357 OMX_INIT_STRUCT(&m_sOutPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
358 m_sOutPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
359 m_sOutPortFormat.nIndex = 0;
360 m_sOutPortFormat.eColorFormat = OMX_COLOR_FormatUnused;
361 if (codec_type == OMX_VIDEO_CodingMPEG4) {
362 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
363 } else if (codec_type == OMX_VIDEO_CodingH263) {
364 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingH263;
365 } else if (codec_type == OMX_VIDEO_CodingAVC) {
366 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingAVC;
367 } else if (codec_type == OMX_VIDEO_CodingVP8) {
368 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingVP8;
369 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
370 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingHEVC;
371 }
372
373
374 // mandatory Indices for kronos test suite
375 OMX_INIT_STRUCT(&m_sPriorityMgmt, OMX_PRIORITYMGMTTYPE);
376
377 OMX_INIT_STRUCT(&m_sInBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
378 m_sInBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_IN;
379
380 OMX_INIT_STRUCT(&m_sOutBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
381 m_sOutBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
382
383 OMX_INIT_STRUCT(&m_sParamInitqp, QOMX_EXTNINDEX_VIDEO_INITIALQP);
384 m_sParamInitqp.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
385
386 // mp4 specific init
387 OMX_INIT_STRUCT(&m_sParamMPEG4, OMX_VIDEO_PARAM_MPEG4TYPE);
388 m_sParamMPEG4.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
389 m_sParamMPEG4.eProfile = OMX_VIDEO_MPEG4ProfileSimple;
390 m_sParamMPEG4.eLevel = OMX_VIDEO_MPEG4Level0;
391 m_sParamMPEG4.nSliceHeaderSpacing = 0;
392 m_sParamMPEG4.bSVH = OMX_FALSE;
393 m_sParamMPEG4.bGov = OMX_FALSE;
394 m_sParamMPEG4.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps
395 m_sParamMPEG4.bACPred = OMX_TRUE;
396 m_sParamMPEG4.nTimeIncRes = 30; // delta = 2 @ 15 fps
397 m_sParamMPEG4.nAllowedPictureTypes = 2; // pframe and iframe
398 m_sParamMPEG4.nHeaderExtension = 1; // number of video packet headers per vop
399 m_sParamMPEG4.bReversibleVLC = OMX_FALSE;
400
401 // h263 specific init
402 OMX_INIT_STRUCT(&m_sParamH263, OMX_VIDEO_PARAM_H263TYPE);
403 m_sParamH263.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
404 m_sParamH263.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps
405 m_sParamH263.nBFrames = 0;
406 m_sParamH263.eProfile = OMX_VIDEO_H263ProfileBaseline;
407 m_sParamH263.eLevel = OMX_VIDEO_H263Level10;
408 m_sParamH263.bPLUSPTYPEAllowed = OMX_FALSE;
409 m_sParamH263.nAllowedPictureTypes = 2;
410 m_sParamH263.bForceRoundingTypeToZero = OMX_TRUE;
411 m_sParamH263.nPictureHeaderRepetition = 0;
412 m_sParamH263.nGOBHeaderInterval = 1;
413
414 // h264 specific init
415 OMX_INIT_STRUCT(&m_sParamAVC, OMX_VIDEO_PARAM_AVCTYPE);
416 m_sParamAVC.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
417 m_sParamAVC.nSliceHeaderSpacing = 0;
418 m_sParamAVC.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps
419 m_sParamAVC.nBFrames = 0;
420 m_sParamAVC.bUseHadamard = OMX_FALSE;
421 m_sParamAVC.nRefFrames = 1;
422 m_sParamAVC.nRefIdx10ActiveMinus1 = 1;
423 m_sParamAVC.nRefIdx11ActiveMinus1 = 0;
424 m_sParamAVC.bEnableUEP = OMX_FALSE;
425 m_sParamAVC.bEnableFMO = OMX_FALSE;
426 m_sParamAVC.bEnableASO = OMX_FALSE;
427 m_sParamAVC.bEnableRS = OMX_FALSE;
428 m_sParamAVC.eProfile = OMX_VIDEO_AVCProfileBaseline;
429 m_sParamAVC.eLevel = OMX_VIDEO_AVCLevel1;
430 m_sParamAVC.nAllowedPictureTypes = 2;
431 m_sParamAVC.bFrameMBsOnly = OMX_FALSE;
432 m_sParamAVC.bMBAFF = OMX_FALSE;
433 m_sParamAVC.bEntropyCodingCABAC = OMX_FALSE;
434 m_sParamAVC.bWeightedPPrediction = OMX_FALSE;
435 m_sParamAVC.nWeightedBipredicitonMode = 0;
436 m_sParamAVC.bconstIpred = OMX_FALSE;
437 m_sParamAVC.bDirect8x8Inference = OMX_FALSE;
438 m_sParamAVC.bDirectSpatialTemporal = OMX_FALSE;
439 m_sParamAVC.nCabacInitIdc = 0;
440 m_sParamAVC.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
441
442 // VP8 specific init
443 OMX_INIT_STRUCT(&m_sParamVP8, OMX_VIDEO_PARAM_VP8TYPE);
444 m_sParamVP8.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
445 m_sParamVP8.eProfile = OMX_VIDEO_VP8ProfileMain;
446 m_sParamVP8.eLevel = OMX_VIDEO_VP8Level_Version0;
447 m_sParamVP8.nDCTPartitions = 0;
448 m_sParamVP8.bErrorResilientMode = OMX_FALSE;
449
450 // HEVC specific init
451 OMX_INIT_STRUCT(&m_sParamHEVC, OMX_VIDEO_PARAM_HEVCTYPE);
452 m_sParamHEVC.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
453 m_sParamHEVC.eProfile = OMX_VIDEO_HEVCProfileMain;
454 m_sParamHEVC.eLevel = OMX_VIDEO_HEVCMainTierLevel1;
455
456 OMX_INIT_STRUCT(&m_sParamLTRMode, QOMX_VIDEO_PARAM_LTRMODE_TYPE);
457 m_sParamLTRMode.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
458 m_sParamLTRMode.eLTRMode = QOMX_VIDEO_LTRMode_Disable;
459
460 OMX_INIT_STRUCT(&m_sParamLTRCount, QOMX_VIDEO_PARAM_LTRCOUNT_TYPE);
461 m_sParamLTRCount.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
462 m_sParamLTRCount.nCount = 0;
463
464 OMX_INIT_STRUCT(&m_sConfigDeinterlace, OMX_VIDEO_CONFIG_DEINTERLACE);
465 m_sConfigDeinterlace.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
466 m_sConfigDeinterlace.nEnable = OMX_FALSE;
467
468 OMX_INIT_STRUCT(&m_sHierLayers, QOMX_VIDEO_HIERARCHICALLAYERS);
469 m_sHierLayers.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
470 m_sHierLayers.nNumLayers = 0;
471 m_sHierLayers.eHierarchicalCodingType = QOMX_HIERARCHICALCODING_P;
472
473 memset(&m_sParamTemporalLayers, 0x0, sizeof(OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE));
474 OMX_INIT_STRUCT(&m_sParamTemporalLayers, OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE);
475 m_sParamTemporalLayers.eSupportedPatterns = OMX_VIDEO_AndroidTemporalLayeringPatternAndroid;
476
477 memset(&m_sConfigTemporalLayers, 0x0, sizeof(OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE));
478 OMX_INIT_STRUCT(&m_sConfigTemporalLayers, OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE);
479
480 m_state = OMX_StateLoaded;
481 m_sExtraData = 0;
482
483 if (eRet == OMX_ErrorNone) {
484 if (pipe(fds)) {
485 DEBUG_PRINT_ERROR("ERROR: pipe creation failed");
486 eRet = OMX_ErrorInsufficientResources;
487 } else {
488 if (fds[0] == 0 || fds[1] == 0) {
489 if (pipe(fds)) {
490 DEBUG_PRINT_ERROR("ERROR: pipe creation failed");
491 eRet = OMX_ErrorInsufficientResources;
492 }
493 }
494 if (eRet == OMX_ErrorNone) {
495 m_pipe_in = fds[0];
496 m_pipe_out = fds[1];
497 }
498 }
499 msg_thread_created = true;
500 r = pthread_create(&msg_thread_id,0, message_thread, this);
501 if (r < 0) {
502 eRet = OMX_ErrorInsufficientResources;
503 msg_thread_created = false;
504 } else {
505 async_thread_created = true;
506 r = pthread_create(&async_thread_id,0, venc_dev::async_venc_message_thread, this);
507 if (r < 0) {
508 eRet = OMX_ErrorInsufficientResources;
509 async_thread_created = false;
510 } else
511 dev_set_message_thread_id(async_thread_id);
512 }
513 }
514
515 if (perfmode) {
516 QOMX_EXTNINDEX_VIDEO_PERFMODE pParam;
517 pParam.nPerfMode = perfmode;
518 DEBUG_PRINT_LOW("Perfmode = 0x%x", pParam.nPerfMode);
519 if (!handle->venc_set_config(&pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode))
520 DEBUG_PRINT_ERROR("Failed setting PerfMode to %d", pParam.nPerfMode);
521 }
522
523 if (hybrid_hp)
524 {
525 if (hybrid_hp <= MAX_HYB_HIERP_LAYERS) {
526 QOMX_EXTNINDEX_VIDEO_HYBRID_HP_MODE hyb_hp;
527 hyb_hp.nHpLayers = hybrid_hp;
528 DEBUG_PRINT_LOW("hybrid_hp = 0x%x", hyb_hp.nHpLayers);
529 if (!handle->venc_set_param(&hyb_hp, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoHybridHierpMode)) {
530 DEBUG_PRINT_ERROR("Failed setting hybrid_hp to %d", hyb_hp.nHpLayers);
531 }
532 } else {
533 DEBUG_PRINT_ERROR("Max hybrid_hp layers supported is %d", hybrid_hp);
534 }
535 }
536 DEBUG_PRINT_INFO("Component_init : %s : return = 0x%x", m_nkind, eRet);
537 return eRet;
538 init_error:
539 handle->venc_close();
540 delete handle;
541 handle = NULL;
542 return eRet;
543 }
544
545
546 /* ======================================================================
547 FUNCTION
548 omx_venc::Setparameter
549
550 DESCRIPTION
551 OMX Set Parameter method implementation.
552
553 PARAMETERS
554 <TBD>.
555
556 RETURN VALUE
557 OMX Error None if successful.
558
559 ========================================================================== */
set_parameter(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_INDEXTYPE paramIndex,OMX_IN OMX_PTR paramData)560 OMX_ERRORTYPE omx_venc::set_parameter(OMX_IN OMX_HANDLETYPE hComp,
561 OMX_IN OMX_INDEXTYPE paramIndex,
562 OMX_IN OMX_PTR paramData)
563 {
564 (void)hComp;
565 OMX_ERRORTYPE eRet = OMX_ErrorNone;
566
567
568 if (m_state == OMX_StateInvalid) {
569 DEBUG_PRINT_ERROR("ERROR: Set Param in Invalid State");
570 return OMX_ErrorInvalidState;
571 }
572 if (paramData == NULL) {
573 DEBUG_PRINT_ERROR("ERROR: Get Param in Invalid paramData");
574 return OMX_ErrorBadParameter;
575 }
576
577 /*set_parameter can be called in loaded state
578 or disabled port */
579 if (m_state == OMX_StateLoaded
580 || m_sInPortDef.bEnabled == OMX_FALSE
581 || m_sOutPortDef.bEnabled == OMX_FALSE) {
582 DEBUG_PRINT_LOW("Set Parameter called in valid state");
583 } else {
584 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State");
585 return OMX_ErrorIncorrectStateOperation;
586 }
587
588 switch ((int)paramIndex) {
589 case OMX_IndexParamPortDefinition:
590 {
591 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_PORTDEFINITIONTYPE);
592 OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
593 portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
594 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPortDefinition H= %d, W = %d",
595 (int)portDefn->format.video.nFrameHeight,
596 (int)portDefn->format.video.nFrameWidth);
597
598 if (PORT_INDEX_IN == portDefn->nPortIndex) {
599 if (!dev_is_video_session_supported(portDefn->format.video.nFrameWidth,
600 portDefn->format.video.nFrameHeight)) {
601 DEBUG_PRINT_ERROR("video session not supported");
602 omx_report_unsupported_setting();
603 return OMX_ErrorUnsupportedSetting;
604 }
605 DEBUG_PRINT_LOW("i/p actual cnt requested = %u", (unsigned int)portDefn->nBufferCountActual);
606 DEBUG_PRINT_LOW("i/p min cnt requested = %u", (unsigned int)portDefn->nBufferCountMin);
607 DEBUG_PRINT_LOW("i/p buffersize requested = %u", (unsigned int)portDefn->nBufferSize);
608 if (portDefn->nBufferCountActual > MAX_NUM_INPUT_BUFFERS) {
609 DEBUG_PRINT_ERROR("ERROR: (In_PORT) actual count (%u) exceeds max(%u)",
610 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_INPUT_BUFFERS);
611 return OMX_ErrorUnsupportedSetting;
612 }
613 if (m_inp_mem_ptr &&
614 (portDefn->nBufferCountActual != m_sInPortDef.nBufferCountActual ||
615 portDefn->nBufferSize != m_sInPortDef.nBufferSize)) {
616 DEBUG_PRINT_ERROR("ERROR: (In_PORT) buffer count/size can change only if port is unallocated !");
617 return OMX_ErrorInvalidState;
618 }
619 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) {
620 DEBUG_PRINT_ERROR("ERROR: (In_PORT) Min buffers (%u) > actual count (%u)",
621 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual);
622 return OMX_ErrorUnsupportedSetting;
623 }
624 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) {
625 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed");
626 return handle->hw_overload ? OMX_ErrorInsufficientResources :
627 OMX_ErrorUnsupportedSetting;
628 }
629
630 DEBUG_PRINT_LOW("i/p previous actual cnt = %u", (unsigned int)m_sInPortDef.nBufferCountActual);
631 DEBUG_PRINT_LOW("i/p previous min cnt = %u", (unsigned int)m_sInPortDef.nBufferCountMin);
632 memcpy(&m_sInPortDef, portDefn,sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
633
634 #ifdef _ANDROID_ICS_
635 if (portDefn->format.video.eColorFormat ==
636 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) {
637 m_sInPortDef.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)
638 QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m;
639 if (!mUseProxyColorFormat) {
640 if (!c2d_conv.init()) {
641 DEBUG_PRINT_ERROR("C2D init failed");
642 return OMX_ErrorUnsupportedSetting;
643 }
644 DEBUG_PRINT_HIGH("C2D init is successful");
645 }
646 mUseProxyColorFormat = true;
647 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ;
648 } else
649 mUseProxyColorFormat = false;
650 #endif
651 /*Query Input Buffer Requirements*/
652 dev_get_buf_req (&m_sInPortDef.nBufferCountMin,
653 &m_sInPortDef.nBufferCountActual,
654 &m_sInPortDef.nBufferSize,
655 m_sInPortDef.nPortIndex);
656
657 /*Query ouput Buffer Requirements*/
658 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin,
659 &m_sOutPortDef.nBufferCountActual,
660 &m_sOutPortDef.nBufferSize,
661 m_sOutPortDef.nPortIndex);
662 m_sInPortDef.nBufferCountActual = portDefn->nBufferCountActual;
663 } else if (PORT_INDEX_OUT == portDefn->nPortIndex) {
664 DEBUG_PRINT_LOW("o/p actual cnt requested = %u", (unsigned int)portDefn->nBufferCountActual);
665 DEBUG_PRINT_LOW("o/p min cnt requested = %u", (unsigned int)portDefn->nBufferCountMin);
666 DEBUG_PRINT_LOW("o/p buffersize requested = %u", (unsigned int)portDefn->nBufferSize);
667
668 if (portDefn->nBufferCountActual > MAX_NUM_OUTPUT_BUFFERS) {
669 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) actual count (%u) exceeds max(%u)",
670 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_OUTPUT_BUFFERS);
671 return OMX_ErrorUnsupportedSetting;
672 }
673 if (m_out_mem_ptr &&
674 (portDefn->nBufferCountActual != m_sOutPortDef.nBufferCountActual ||
675 portDefn->nBufferSize != m_sOutPortDef.nBufferSize)) {
676 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) buffer count/size can change only if port is unallocated !");
677 return OMX_ErrorInvalidState;
678 }
679
680 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) {
681 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) Min buffers (%u) > actual count (%u)",
682 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual);
683 return OMX_ErrorUnsupportedSetting;
684 }
685 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) {
686 DEBUG_PRINT_ERROR("ERROR: venc_set_param output failed");
687 return OMX_ErrorUnsupportedSetting;
688 }
689 #ifdef _MSM8974_
690 /*Query ouput Buffer Requirements*/
691 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
692 &m_sOutPortDef.nBufferCountActual,
693 &m_sOutPortDef.nBufferSize,
694 m_sOutPortDef.nPortIndex);
695 #endif
696 memcpy(&m_sOutPortDef,portDefn,sizeof(struct OMX_PARAM_PORTDEFINITIONTYPE));
697 update_profile_level(); //framerate , bitrate
698
699 DEBUG_PRINT_LOW("o/p previous actual cnt = %u", (unsigned int)m_sOutPortDef.nBufferCountActual);
700 DEBUG_PRINT_LOW("o/p previous min cnt = %u", (unsigned int)m_sOutPortDef.nBufferCountMin);
701 m_sOutPortDef.nBufferCountActual = portDefn->nBufferCountActual;
702 } else {
703 DEBUG_PRINT_ERROR("ERROR: Set_parameter: Bad Port idx %d",
704 (int)portDefn->nPortIndex);
705 eRet = OMX_ErrorBadPortIndex;
706 }
707 m_sConfigFramerate.xEncodeFramerate = portDefn->format.video.xFramerate;
708 m_sConfigBitrate.nEncodeBitrate = portDefn->format.video.nBitrate;
709 m_sParamBitrate.nTargetBitrate = portDefn->format.video.nBitrate;
710 }
711 break;
712
713 case OMX_IndexParamVideoPortFormat:
714 {
715 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PORTFORMATTYPE);
716 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt =
717 (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData;
718 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d",
719 portFmt->eColorFormat);
720 //set the driver with the corresponding values
721 if (PORT_INDEX_IN == portFmt->nPortIndex) {
722 if (handle->venc_set_param(paramData,OMX_IndexParamVideoPortFormat) != true) {
723 return OMX_ErrorUnsupportedSetting;
724 }
725
726 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d",
727 portFmt->eColorFormat);
728 update_profile_level(); //framerate
729
730 #ifdef _ANDROID_ICS_
731 if (portFmt->eColorFormat ==
732 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) {
733 m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE)
734 QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m;
735 if (!mUseProxyColorFormat) {
736 if (!c2d_conv.init()) {
737 DEBUG_PRINT_ERROR("C2D init failed");
738 return OMX_ErrorUnsupportedSetting;
739 }
740 DEBUG_PRINT_HIGH("C2D init is successful");
741 }
742 mUseProxyColorFormat = true;
743 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ;
744 } else
745 #endif
746 {
747 m_sInPortFormat.eColorFormat = portFmt->eColorFormat;
748 m_sInPortDef.format.video.eColorFormat = portFmt->eColorFormat;
749 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB;
750 mUseProxyColorFormat = false;
751 }
752 m_sInPortFormat.xFramerate = portFmt->xFramerate;
753 }
754 //TODO if no use case for O/P port,delet m_sOutPortFormat
755 }
756 break;
757 case OMX_IndexParamVideoInit:
758 { //TODO, do we need this index set param
759 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PORT_PARAM_TYPE);
760 OMX_PORT_PARAM_TYPE* pParam = (OMX_PORT_PARAM_TYPE*)(paramData);
761 DEBUG_PRINT_LOW("Set OMX_IndexParamVideoInit called");
762 break;
763 }
764
765 case OMX_IndexParamVideoBitrate:
766 {
767 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_BITRATETYPE);
768 OMX_VIDEO_PARAM_BITRATETYPE* pParam = (OMX_VIDEO_PARAM_BITRATETYPE*)paramData;
769 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoBitrate");
770 if (handle->venc_set_param(paramData,OMX_IndexParamVideoBitrate) != true) {
771 return OMX_ErrorUnsupportedSetting;
772 }
773 m_sParamBitrate.nTargetBitrate = pParam->nTargetBitrate;
774 m_sParamBitrate.eControlRate = pParam->eControlRate;
775 update_profile_level(); //bitrate
776 m_sConfigBitrate.nEncodeBitrate = pParam->nTargetBitrate;
777 m_sInPortDef.format.video.nBitrate = pParam->nTargetBitrate;
778 m_sOutPortDef.format.video.nBitrate = pParam->nTargetBitrate;
779 DEBUG_PRINT_LOW("bitrate = %u", (unsigned int)m_sOutPortDef.format.video.nBitrate);
780 break;
781 }
782 case OMX_IndexParamVideoMpeg4:
783 {
784 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_MPEG4TYPE);
785 OMX_VIDEO_PARAM_MPEG4TYPE* pParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)paramData;
786 OMX_VIDEO_PARAM_MPEG4TYPE mp4_param;
787 memcpy(&mp4_param, pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE));
788 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoMpeg4");
789 if (pParam->eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) {
790 #ifdef MAX_RES_1080P
791 if (pParam->nBFrames) {
792 DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported");
793 mp4_param.nBFrames = 1;
794 }
795 #else
796 if (pParam->nBFrames) {
797 DEBUG_PRINT_ERROR("Warning: B frames not supported");
798 mp4_param.nBFrames = 0;
799 }
800 #endif
801 #ifdef _MSM8974_
802 if (pParam->nBFrames || bframes)
803 mp4_param.nBFrames = (pParam->nBFrames > (unsigned int) bframes)? pParam->nBFrames : bframes;
804 DEBUG_PRINT_HIGH("MPEG4: %u BFrames are being set", (unsigned int)mp4_param.nBFrames);
805 #endif
806
807 } else {
808 if (pParam->nBFrames) {
809 DEBUG_PRINT_ERROR("Warning: B frames not supported");
810 mp4_param.nBFrames = 0;
811 }
812 }
813 if (handle->venc_set_param(&mp4_param,OMX_IndexParamVideoMpeg4) != true) {
814 return OMX_ErrorUnsupportedSetting;
815 }
816 memcpy(&m_sParamMPEG4,pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE));
817 m_sIntraperiod.nPFrames = m_sParamMPEG4.nPFrames;
818 if (pParam->nBFrames || bframes)
819 m_sIntraperiod.nBFrames = m_sParamMPEG4.nBFrames = mp4_param.nBFrames;
820 else
821 m_sIntraperiod.nBFrames = m_sParamMPEG4.nBFrames;
822 break;
823 }
824 case OMX_IndexParamVideoH263:
825 {
826 OMX_VIDEO_PARAM_H263TYPE* pParam = (OMX_VIDEO_PARAM_H263TYPE*)paramData;
827 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoH263");
828 if (handle->venc_set_param(paramData,OMX_IndexParamVideoH263) != true) {
829 return OMX_ErrorUnsupportedSetting;
830 }
831 memcpy(&m_sParamH263,pParam, sizeof(struct OMX_VIDEO_PARAM_H263TYPE));
832 m_sIntraperiod.nPFrames = m_sParamH263.nPFrames;
833 m_sIntraperiod.nBFrames = m_sParamH263.nBFrames;
834 break;
835 }
836 case OMX_IndexParamVideoAvc:
837 {
838 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_AVCTYPE);
839 OMX_VIDEO_PARAM_AVCTYPE* pParam = (OMX_VIDEO_PARAM_AVCTYPE*)paramData;
840 OMX_VIDEO_PARAM_AVCTYPE avc_param;
841 memcpy(&avc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_AVCTYPE));
842 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAvc");
843
844 if ((pParam->eProfile == OMX_VIDEO_AVCProfileHigh)||
845 (pParam->eProfile == OMX_VIDEO_AVCProfileMain)) {
846 #ifdef MAX_RES_1080P
847 if (pParam->nBFrames) {
848 DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported");
849 avc_param.nBFrames = 1;
850 }
851 if (pParam->nRefFrames != 2) {
852 DEBUG_PRINT_ERROR("Warning: 2 RefFrames are needed, changing RefFrames from %u to 2", (unsigned int)pParam->nRefFrames);
853 avc_param.nRefFrames = 2;
854 }
855 #else
856 if (pParam->nBFrames) {
857 DEBUG_PRINT_ERROR("Warning: B frames not supported");
858 avc_param.nBFrames = 0;
859 }
860 if (pParam->nRefFrames != 1) {
861 DEBUG_PRINT_ERROR("Warning: Only 1 RefFrame is supported, changing RefFrame from %u to 1)", (unsigned int)pParam->nRefFrames);
862 avc_param.nRefFrames = 1;
863 }
864 #endif
865 #ifdef _MSM8974_
866 if (pParam->nBFrames || bframes) {
867 avc_param.nBFrames = (pParam->nBFrames > (unsigned int) bframes)? pParam->nBFrames : bframes;
868 avc_param.nRefFrames = (avc_param.nBFrames < 4)? avc_param.nBFrames + 1 : 4;
869 }
870 DEBUG_PRINT_HIGH("AVC: RefFrames: %u, BFrames: %u", (unsigned int)avc_param.nRefFrames, (unsigned int)avc_param.nBFrames);
871
872 avc_param.bEntropyCodingCABAC = (OMX_BOOL)(avc_param.bEntropyCodingCABAC && entropy);
873 avc_param.nCabacInitIdc = entropy ? avc_param.nCabacInitIdc : 0;
874 #endif
875 } else {
876 if (pParam->nRefFrames != 1) {
877 DEBUG_PRINT_ERROR("Warning: Only 1 RefFrame is supported, changing RefFrame from %u to 1)", (unsigned int)pParam->nRefFrames);
878 avc_param.nRefFrames = 1;
879 }
880 if (pParam->nBFrames) {
881 DEBUG_PRINT_ERROR("Warning: B frames not supported");
882 avc_param.nBFrames = 0;
883 }
884 }
885 if (handle->venc_set_param(&avc_param,OMX_IndexParamVideoAvc) != true) {
886 return OMX_ErrorUnsupportedSetting;
887 }
888 memcpy(&m_sParamAVC,pParam, sizeof(struct OMX_VIDEO_PARAM_AVCTYPE));
889 m_sIntraperiod.nPFrames = m_sParamAVC.nPFrames;
890 if (pParam->nBFrames || bframes)
891 m_sIntraperiod.nBFrames = m_sParamAVC.nBFrames = avc_param.nBFrames;
892 else
893 m_sIntraperiod.nBFrames = m_sParamAVC.nBFrames;
894 break;
895 }
896 case (OMX_INDEXTYPE)OMX_IndexParamVideoVp8:
897 {
898 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_VP8TYPE);
899 OMX_VIDEO_PARAM_VP8TYPE* pParam = (OMX_VIDEO_PARAM_VP8TYPE*)paramData;
900 OMX_VIDEO_PARAM_VP8TYPE vp8_param;
901 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoVp8");
902 if (pParam->nDCTPartitions != m_sParamVP8.nDCTPartitions ||
903 pParam->bErrorResilientMode != m_sParamVP8.bErrorResilientMode) {
904 DEBUG_PRINT_ERROR("VP8 doesn't support nDCTPartitions or bErrorResilientMode");
905 }
906 memcpy(&vp8_param, pParam, sizeof( struct OMX_VIDEO_PARAM_VP8TYPE));
907 if (handle->venc_set_param(&vp8_param, (OMX_INDEXTYPE)OMX_IndexParamVideoVp8) != true) {
908 return OMX_ErrorUnsupportedSetting;
909 }
910 memcpy(&m_sParamVP8,pParam, sizeof(struct OMX_VIDEO_PARAM_VP8TYPE));
911 break;
912 }
913 case (OMX_INDEXTYPE)OMX_IndexParamVideoHevc:
914 {
915 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_HEVCTYPE);
916 OMX_VIDEO_PARAM_HEVCTYPE* pParam = (OMX_VIDEO_PARAM_HEVCTYPE*)paramData;
917 OMX_VIDEO_PARAM_HEVCTYPE hevc_param;
918 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoHevc");
919 memcpy(&hevc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_HEVCTYPE));
920 if (handle->venc_set_param(&hevc_param, (OMX_INDEXTYPE)OMX_IndexParamVideoHevc) != true) {
921 DEBUG_PRINT_ERROR("Failed : set_parameter: OMX_IndexParamVideoHevc");
922 return OMX_ErrorUnsupportedSetting;
923 }
924 memcpy(&m_sParamHEVC, pParam, sizeof(struct OMX_VIDEO_PARAM_HEVCTYPE));
925 break;
926 }
927 case OMX_IndexParamVideoProfileLevelCurrent:
928 {
929 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
930 OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData;
931 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoProfileLevelCurrent");
932 if (handle->venc_set_param(pParam,OMX_IndexParamVideoProfileLevelCurrent) != true) {
933 DEBUG_PRINT_ERROR("set_parameter: OMX_IndexParamVideoProfileLevelCurrent failed for Profile: %u "
934 "Level :%u", (unsigned int)pParam->eProfile, (unsigned int)pParam->eLevel);
935 return OMX_ErrorUnsupportedSetting;
936 }
937 m_sParamProfileLevel.eProfile = pParam->eProfile;
938 m_sParamProfileLevel.eLevel = pParam->eLevel;
939
940 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\
941 OMX_MAX_STRINGNAME_SIZE)) {
942 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)m_sParamProfileLevel.eProfile;
943 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)m_sParamProfileLevel.eLevel;
944 DEBUG_PRINT_LOW("MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile,
945 m_sParamMPEG4.eLevel);
946 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\
947 OMX_MAX_STRINGNAME_SIZE)) {
948 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)m_sParamProfileLevel.eProfile;
949 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)m_sParamProfileLevel.eLevel;
950 DEBUG_PRINT_LOW("H263 profile = %d, level = %d", m_sParamH263.eProfile,
951 m_sParamH263.eLevel);
952 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
953 OMX_MAX_STRINGNAME_SIZE)) {
954 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile;
955 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel;
956 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile,
957 m_sParamAVC.eLevel);
958 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
959 OMX_MAX_STRINGNAME_SIZE)) {
960 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile;
961 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel;
962 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile,
963 m_sParamAVC.eLevel);
964 }
965 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",\
966 OMX_MAX_STRINGNAME_SIZE)) {
967 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)m_sParamProfileLevel.eProfile;
968 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)m_sParamProfileLevel.eLevel;
969 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile,
970 m_sParamVP8.eLevel);
971 }
972 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",\
973 OMX_MAX_STRINGNAME_SIZE)) {
974 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)m_sParamProfileLevel.eProfile;
975 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)m_sParamProfileLevel.eLevel;
976 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile,
977 m_sParamHEVC.eLevel);
978 }
979
980 break;
981 }
982 case OMX_IndexParamStandardComponentRole:
983 {
984 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_COMPONENTROLETYPE);
985 OMX_PARAM_COMPONENTROLETYPE *comp_role;
986 comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData;
987 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamStandardComponentRole %s",
988 comp_role->cRole);
989
990 if ((m_state == OMX_StateLoaded)&&
991 !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING)) {
992 DEBUG_PRINT_LOW("Set Parameter called in valid state");
993 } else {
994 DEBUG_PRINT_ERROR("Set Parameter called in Invalid State");
995 return OMX_ErrorIncorrectStateOperation;
996 }
997
998 if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
999 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1000 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
1001 } else {
1002 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1003 eRet =OMX_ErrorUnsupportedSetting;
1004 }
1005 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc.secure",OMX_MAX_STRINGNAME_SIZE)) {
1006 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1007 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
1008 } else {
1009 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s\n", comp_role->cRole);
1010 eRet =OMX_ErrorUnsupportedSetting;
1011 }
1012 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) {
1013 if (!strncmp((const char*)comp_role->cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) {
1014 strlcpy((char*)m_cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE);
1015 } else {
1016 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1017 eRet = OMX_ErrorUnsupportedSetting;
1018 }
1019 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.h263",OMX_MAX_STRINGNAME_SIZE)) {
1020 if (!strncmp((const char*)comp_role->cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE)) {
1021 strlcpy((char*)m_cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE);
1022 } else {
1023 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1024 eRet =OMX_ErrorUnsupportedSetting;
1025 }
1026 }
1027 #ifdef _MSM8974_
1028 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) {
1029 if (!strncmp((const char*)comp_role->cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) {
1030 strlcpy((char*)m_cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE);
1031 } else {
1032 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1033 eRet =OMX_ErrorUnsupportedSetting;
1034 }
1035 }
1036 #endif
1037 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) {
1038 if (!strncmp((const char*)comp_role->cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) {
1039 strlcpy((char*)m_cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE);
1040 } else {
1041 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1042 eRet = OMX_ErrorUnsupportedSetting;
1043 }
1044 }
1045
1046 else {
1047 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %s", m_nkind);
1048 eRet = OMX_ErrorInvalidComponentName;
1049 }
1050 break;
1051 }
1052
1053 case OMX_IndexParamPriorityMgmt:
1054 {
1055 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PRIORITYMGMTTYPE);
1056 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt");
1057 if (m_state != OMX_StateLoaded) {
1058 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State");
1059 return OMX_ErrorIncorrectStateOperation;
1060 }
1061 OMX_PRIORITYMGMTTYPE *priorityMgmtype = (OMX_PRIORITYMGMTTYPE*) paramData;
1062 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt %u",
1063 (unsigned int)priorityMgmtype->nGroupID);
1064
1065 DEBUG_PRINT_LOW("set_parameter: priorityMgmtype %u",
1066 (unsigned int)priorityMgmtype->nGroupPriority);
1067
1068 m_sPriorityMgmt.nGroupID = priorityMgmtype->nGroupID;
1069 m_sPriorityMgmt.nGroupPriority = priorityMgmtype->nGroupPriority;
1070
1071 break;
1072 }
1073
1074 case OMX_IndexParamCompBufferSupplier:
1075 {
1076 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_BUFFERSUPPLIERTYPE);
1077 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier");
1078 OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
1079 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier %d",
1080 bufferSupplierType->eBufferSupplier);
1081 if (bufferSupplierType->nPortIndex == 0 || bufferSupplierType->nPortIndex ==1)
1082 m_sInBufSupplier.eBufferSupplier = bufferSupplierType->eBufferSupplier;
1083
1084 else
1085
1086 eRet = OMX_ErrorBadPortIndex;
1087
1088 break;
1089
1090 }
1091 case OMX_IndexParamVideoQuantization:
1092 {
1093 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
1094 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoQuantization");
1095 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *session_qp = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) paramData;
1096 if (session_qp->nPortIndex == PORT_INDEX_OUT) {
1097 if (handle->venc_set_param(paramData, OMX_IndexParamVideoQuantization) != true) {
1098 return OMX_ErrorUnsupportedSetting;
1099 }
1100 m_sSessionQuantization.nQpI = session_qp->nQpI;
1101 m_sSessionQuantization.nQpP = session_qp->nQpP;
1102 m_sSessionQuantization.nQpB = session_qp->nQpB;
1103 } else {
1104 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for Session QP setting");
1105 eRet = OMX_ErrorBadPortIndex;
1106 }
1107 break;
1108 }
1109
1110 case OMX_QcomIndexParamVideoQPRange:
1111 {
1112 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_QPRANGETYPE);
1113 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexParamVideoQPRange");
1114 OMX_QCOM_VIDEO_PARAM_QPRANGETYPE *qp_range = (OMX_QCOM_VIDEO_PARAM_QPRANGETYPE*) paramData;
1115 if (qp_range->nPortIndex == PORT_INDEX_OUT) {
1116 if (handle->venc_set_param(paramData,
1117 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoQPRange) != true) {
1118 return OMX_ErrorUnsupportedSetting;
1119 }
1120 m_sSessionQPRange.minQP= qp_range->minQP;
1121 m_sSessionQPRange.maxQP= qp_range->maxQP;
1122 } else {
1123 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for QP range setting");
1124 eRet = OMX_ErrorBadPortIndex;
1125 }
1126 break;
1127 }
1128
1129 case OMX_QcomIndexPortDefn:
1130 {
1131 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_PARAM_PORTDEFINITIONTYPE);
1132 OMX_QCOM_PARAM_PORTDEFINITIONTYPE* pParam =
1133 (OMX_QCOM_PARAM_PORTDEFINITIONTYPE*)paramData;
1134 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexPortDefn");
1135 if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_IN) {
1136 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid &&
1137 pParam->nMemRegion < OMX_QCOM_MemRegionMax) {
1138 m_use_input_pmem = OMX_TRUE;
1139 } else {
1140 m_use_input_pmem = OMX_FALSE;
1141 }
1142 } else if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_OUT) {
1143 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid &&
1144 pParam->nMemRegion < OMX_QCOM_MemRegionMax) {
1145 m_use_output_pmem = OMX_TRUE;
1146 } else {
1147 m_use_output_pmem = OMX_FALSE;
1148 }
1149 } else {
1150 DEBUG_PRINT_ERROR("ERROR: SetParameter called on unsupported Port Index for QcomPortDefn");
1151 return OMX_ErrorBadPortIndex;
1152 }
1153 break;
1154 }
1155
1156 case OMX_IndexParamVideoErrorCorrection:
1157 {
1158 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
1159 DEBUG_PRINT_LOW("OMX_IndexParamVideoErrorCorrection");
1160 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* pParam =
1161 (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)paramData;
1162 if (!handle->venc_set_param(paramData, OMX_IndexParamVideoErrorCorrection)) {
1163 DEBUG_PRINT_ERROR("ERROR: Request for setting Error Resilience failed");
1164 return OMX_ErrorUnsupportedSetting;
1165 }
1166 memcpy(&m_sErrorCorrection,pParam, sizeof(m_sErrorCorrection));
1167 break;
1168 }
1169 case OMX_IndexParamVideoIntraRefresh:
1170 {
1171 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
1172 DEBUG_PRINT_LOW("set_param:OMX_IndexParamVideoIntraRefresh");
1173 OMX_VIDEO_PARAM_INTRAREFRESHTYPE* pParam =
1174 (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*)paramData;
1175 if (!handle->venc_set_param(paramData,OMX_IndexParamVideoIntraRefresh)) {
1176 DEBUG_PRINT_ERROR("ERROR: Request for setting intra refresh failed");
1177 return OMX_ErrorUnsupportedSetting;
1178 }
1179 memcpy(&m_sIntraRefresh, pParam, sizeof(m_sIntraRefresh));
1180 break;
1181 }
1182 #ifdef _ANDROID_ICS_
1183 case OMX_QcomIndexParamVideoMetaBufferMode:
1184 {
1185 VALIDATE_OMX_PARAM_DATA(paramData, StoreMetaDataInBuffersParams);
1186 StoreMetaDataInBuffersParams *pParam =
1187 (StoreMetaDataInBuffersParams*)paramData;
1188 DEBUG_PRINT_HIGH("set_parameter:OMX_QcomIndexParamVideoMetaBufferMode: "
1189 "port_index = %u, meta_mode = %d", (unsigned int)pParam->nPortIndex, pParam->bStoreMetaData);
1190 if (pParam->nPortIndex == PORT_INDEX_IN) {
1191 if (pParam->bStoreMetaData != meta_mode_enable) {
1192 if (!handle->venc_set_meta_mode(pParam->bStoreMetaData)) {
1193 DEBUG_PRINT_ERROR("ERROR: set Metabuffer mode %d fail",
1194 pParam->bStoreMetaData);
1195 return OMX_ErrorUnsupportedSetting;
1196 }
1197 meta_mode_enable = pParam->bStoreMetaData;
1198 if (meta_mode_enable) {
1199 m_sInPortDef.nBufferCountActual = m_sInPortDef.nBufferCountMin;
1200 if (handle->venc_set_param(&m_sInPortDef,OMX_IndexParamPortDefinition) != true) {
1201 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed");
1202 return OMX_ErrorUnsupportedSetting;
1203 }
1204 } else {
1205 /*TODO: reset encoder driver Meta mode*/
1206 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin,
1207 &m_sOutPortDef.nBufferCountActual,
1208 &m_sOutPortDef.nBufferSize,
1209 m_sOutPortDef.nPortIndex);
1210 }
1211 }
1212 } else if (pParam->nPortIndex == PORT_INDEX_OUT && secure_session) {
1213 if (pParam->bStoreMetaData != meta_mode_enable) {
1214 if (!handle->venc_set_meta_mode(pParam->bStoreMetaData)) {
1215 DEBUG_PRINT_ERROR("\nERROR: set Metabuffer mode %d fail",
1216 pParam->bStoreMetaData);
1217 return OMX_ErrorUnsupportedSetting;
1218 }
1219 meta_mode_enable = pParam->bStoreMetaData;
1220 }
1221 } else {
1222 DEBUG_PRINT_ERROR("set_parameter: metamode is "
1223 "valid for input port only");
1224 eRet = OMX_ErrorUnsupportedIndex;
1225 }
1226 }
1227 break;
1228 #endif
1229 #if !defined(MAX_RES_720P) || defined(_MSM8974_)
1230 case OMX_QcomIndexParamIndexExtraDataType:
1231 {
1232 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_INDEXEXTRADATATYPE);
1233 DEBUG_PRINT_HIGH("set_parameter: OMX_QcomIndexParamIndexExtraDataType");
1234 QOMX_INDEXEXTRADATATYPE *pParam = (QOMX_INDEXEXTRADATATYPE *)paramData;
1235 bool enable = false;
1236 OMX_U32 mask = 0;
1237
1238 if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderSliceInfo) {
1239 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1240 mask = VEN_EXTRADATA_SLICEINFO;
1241
1242 DEBUG_PRINT_HIGH("SliceInfo extradata %s",
1243 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1244 } else {
1245 DEBUG_PRINT_ERROR("set_parameter: Slice information is "
1246 "valid for output port only");
1247 eRet = OMX_ErrorUnsupportedIndex;
1248 break;
1249 }
1250 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderMBInfo) {
1251 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1252 mask = VEN_EXTRADATA_MBINFO;
1253
1254 DEBUG_PRINT_HIGH("MBInfo extradata %s",
1255 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1256 } else {
1257 DEBUG_PRINT_ERROR("set_parameter: MB information is "
1258 "valid for output port only");
1259 eRet = OMX_ErrorUnsupportedIndex;
1260 break;
1261 }
1262 }
1263 #ifndef _MSM8974_
1264 else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoLTRInfo) {
1265 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1266 if (pParam->bEnabled == OMX_TRUE)
1267 mask = VEN_EXTRADATA_LTRINFO;
1268
1269 DEBUG_PRINT_HIGH("LTRInfo extradata %s",
1270 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1271 } else {
1272 DEBUG_PRINT_ERROR("set_parameter: LTR information is "
1273 "valid for output port only");
1274 eRet = OMX_ErrorUnsupportedIndex;
1275 break;
1276 }
1277 }
1278 #endif
1279 else {
1280 DEBUG_PRINT_ERROR("set_parameter: unsupported extrdata index (%x)",
1281 pParam->nIndex);
1282 eRet = OMX_ErrorUnsupportedIndex;
1283 break;
1284 }
1285
1286
1287 if (pParam->bEnabled == OMX_TRUE)
1288 m_sExtraData |= mask;
1289 else
1290 m_sExtraData &= ~mask;
1291
1292 enable = !!(m_sExtraData & mask);
1293 if (handle->venc_set_param(&enable,
1294 (OMX_INDEXTYPE)pParam->nIndex) != true) {
1295 DEBUG_PRINT_ERROR("ERROR: Setting Extradata (%x) failed", pParam->nIndex);
1296 return OMX_ErrorUnsupportedSetting;
1297 } else {
1298 m_sOutPortDef.nPortIndex = PORT_INDEX_OUT;
1299 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
1300 &m_sOutPortDef.nBufferCountActual,
1301 &m_sOutPortDef.nBufferSize,
1302 m_sOutPortDef.nPortIndex);
1303 DEBUG_PRINT_HIGH("updated out_buf_req: buffer cnt=%u, "
1304 "count min=%u, buffer size=%u",
1305 (unsigned int)m_sOutPortDef.nBufferCountActual,
1306 (unsigned int)m_sOutPortDef.nBufferCountMin,
1307 (unsigned int)m_sOutPortDef.nBufferSize);
1308 }
1309 break;
1310 }
1311 case QOMX_IndexParamVideoLTRMode:
1312 {
1313 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_LTRMODE_TYPE);
1314 QOMX_VIDEO_PARAM_LTRMODE_TYPE* pParam =
1315 (QOMX_VIDEO_PARAM_LTRMODE_TYPE*)paramData;
1316 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRMode)) {
1317 DEBUG_PRINT_ERROR("ERROR: Setting LTR mode failed");
1318 return OMX_ErrorUnsupportedSetting;
1319 }
1320 memcpy(&m_sParamLTRMode, pParam, sizeof(m_sParamLTRMode));
1321 break;
1322 }
1323 case QOMX_IndexParamVideoLTRCount:
1324 {
1325 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_LTRCOUNT_TYPE);
1326 QOMX_VIDEO_PARAM_LTRCOUNT_TYPE* pParam =
1327 (QOMX_VIDEO_PARAM_LTRCOUNT_TYPE*)paramData;
1328 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRCount)) {
1329 DEBUG_PRINT_ERROR("ERROR: Setting LTR count failed");
1330 return OMX_ErrorUnsupportedSetting;
1331 }
1332 memcpy(&m_sParamLTRCount, pParam, sizeof(m_sParamLTRCount));
1333 break;
1334 }
1335 #endif
1336 case OMX_QcomIndexParamVideoMaxAllowedBitrateCheck:
1337 {
1338 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1339 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1340 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1341 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1342 handle->m_max_allowed_bitrate_check =
1343 ((pParam->bEnable == OMX_TRUE) ? true : false);
1344 DEBUG_PRINT_HIGH("set_parameter: max allowed bitrate check %s",
1345 ((pParam->bEnable == OMX_TRUE) ? "enabled" : "disabled"));
1346 } else {
1347 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexParamVideoMaxAllowedBitrateCheck "
1348 " called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1349 return OMX_ErrorBadPortIndex;
1350 }
1351 break;
1352 }
1353 #ifdef MAX_RES_1080P
1354 case OMX_QcomIndexEnableSliceDeliveryMode:
1355 {
1356 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1357 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1358 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1359 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1360 if (!handle->venc_set_param(paramData,
1361 (OMX_INDEXTYPE)OMX_QcomIndexEnableSliceDeliveryMode)) {
1362 DEBUG_PRINT_ERROR("ERROR: Request for setting slice delivery mode failed");
1363 return OMX_ErrorUnsupportedSetting;
1364 }
1365 } else {
1366 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableSliceDeliveryMode "
1367 "called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1368 return OMX_ErrorBadPortIndex;
1369 }
1370 break;
1371 }
1372 #endif
1373 case OMX_QcomIndexEnableH263PlusPType:
1374 {
1375 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1376 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1377 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1378 DEBUG_PRINT_LOW("OMX_QcomIndexEnableH263PlusPType");
1379 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1380 if (!handle->venc_set_param(paramData,
1381 (OMX_INDEXTYPE)OMX_QcomIndexEnableH263PlusPType)) {
1382 DEBUG_PRINT_ERROR("ERROR: Request for setting PlusPType failed");
1383 return OMX_ErrorUnsupportedSetting;
1384 }
1385 } else {
1386 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableH263PlusPType "
1387 "called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1388 return OMX_ErrorBadPortIndex;
1389 }
1390 break;
1391 }
1392 case OMX_QcomIndexParamSequenceHeaderWithIDR:
1393 {
1394 VALIDATE_OMX_PARAM_DATA(paramData, PrependSPSPPSToIDRFramesParams);
1395 if(!handle->venc_set_param(paramData,
1396 (OMX_INDEXTYPE)OMX_QcomIndexParamSequenceHeaderWithIDR)) {
1397 DEBUG_PRINT_ERROR("%s: %s",
1398 "OMX_QComIndexParamSequenceHeaderWithIDR:",
1399 "request for inband sps/pps failed.");
1400 return OMX_ErrorUnsupportedSetting;
1401 }
1402 break;
1403 }
1404 case OMX_QcomIndexParamH264AUDelimiter:
1405 {
1406 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_CONFIG_H264_AUD);
1407 if(!handle->venc_set_param(paramData,
1408 (OMX_INDEXTYPE)OMX_QcomIndexParamH264AUDelimiter)) {
1409 DEBUG_PRINT_ERROR("%s: %s",
1410 "OMX_QComIndexParamh264AUDelimiter:",
1411 "request for AU Delimiters failed.");
1412 return OMX_ErrorUnsupportedSetting;
1413 }
1414 break;
1415 }
1416 case OMX_QcomIndexHierarchicalStructure:
1417 {
1418 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_HIERARCHICALLAYERS);
1419 QOMX_VIDEO_HIERARCHICALLAYERS* pParam =
1420 (QOMX_VIDEO_HIERARCHICALLAYERS*)paramData;
1421 DEBUG_PRINT_LOW("OMX_QcomIndexHierarchicalStructure");
1422 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1423 if (!handle->venc_set_param(paramData,
1424 (OMX_INDEXTYPE)OMX_QcomIndexHierarchicalStructure)) {
1425 DEBUG_PRINT_ERROR("ERROR: Request for setting PlusPType failed");
1426 return OMX_ErrorUnsupportedSetting;
1427 }
1428 if((pParam->eHierarchicalCodingType == QOMX_HIERARCHICALCODING_B) && pParam->nNumLayers)
1429 hier_b_enabled = true;
1430 m_sHierLayers.nNumLayers = pParam->nNumLayers;
1431 m_sHierLayers.eHierarchicalCodingType = pParam->eHierarchicalCodingType;
1432 } else {
1433 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexHierarchicalStructure called on wrong port(%u)",
1434 (unsigned int)pParam->nPortIndex);
1435 return OMX_ErrorBadPortIndex;
1436 }
1437 break;
1438
1439 }
1440 case OMX_QcomIndexParamPerfLevel:
1441 {
1442 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_PERF_LEVEL);
1443 if (!handle->venc_set_param(paramData,
1444 (OMX_INDEXTYPE) OMX_QcomIndexParamPerfLevel)) {
1445 DEBUG_PRINT_ERROR("ERROR: Setting performance level");
1446 return OMX_ErrorUnsupportedSetting;
1447 }
1448 break;
1449 }
1450 case OMX_QcomIndexParamH264VUITimingInfo:
1451 {
1452 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_VUI_TIMING_INFO);
1453 if (!handle->venc_set_param(paramData,
1454 (OMX_INDEXTYPE) OMX_QcomIndexParamH264VUITimingInfo)) {
1455 DEBUG_PRINT_ERROR("ERROR: Setting VUI timing info");
1456 return OMX_ErrorUnsupportedSetting;
1457 }
1458 break;
1459 }
1460 case OMX_QcomIndexParamPeakBitrate:
1461 {
1462 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_PEAK_BITRATE);
1463 if (!handle->venc_set_param(paramData,
1464 (OMX_INDEXTYPE) OMX_QcomIndexParamPeakBitrate)) {
1465 DEBUG_PRINT_ERROR("ERROR: Setting peak bitrate");
1466 return OMX_ErrorUnsupportedSetting;
1467 }
1468 break;
1469 }
1470 case QOMX_IndexParamVideoInitialQp:
1471 {
1472 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_INITIALQP);
1473 if(!handle->venc_set_param(paramData,
1474 (OMX_INDEXTYPE)QOMX_IndexParamVideoInitialQp)) {
1475 DEBUG_PRINT_ERROR("Request to Enable initial QP failed");
1476 return OMX_ErrorUnsupportedSetting;
1477 }
1478 memcpy(&m_sParamInitqp, paramData, sizeof(m_sParamInitqp));
1479 break;
1480 }
1481 case OMX_QcomIndexParamSetMVSearchrange:
1482 {
1483 if (!handle->venc_set_param(paramData,
1484 (OMX_INDEXTYPE) OMX_QcomIndexParamSetMVSearchrange)) {
1485 DEBUG_PRINT_ERROR("ERROR: Setting Searchrange");
1486 return OMX_ErrorUnsupportedSetting;
1487 }
1488 break;
1489 }
1490 case OMX_QcomIndexParamVideoHybridHierpMode:
1491 {
1492 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_HYBRID_HP_MODE);
1493 if(!handle->venc_set_param(paramData,
1494 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoHybridHierpMode)) {
1495 DEBUG_PRINT_ERROR("Request to Enable Hybrid Hier-P failed");
1496 return OMX_ErrorUnsupportedSetting;
1497 }
1498 break;
1499 }
1500 case OMX_IndexParamAndroidVideoTemporalLayering:
1501 {
1502 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE);
1503 if (!handle->venc_set_param(paramData,
1504 (OMX_INDEXTYPE)OMX_IndexParamAndroidVideoTemporalLayering)) {
1505 DEBUG_PRINT_ERROR("Failed to configure temporal layers");
1506 return OMX_ErrorUnsupportedSetting;
1507 }
1508 // save the actual configuration applied
1509 memcpy(&m_sParamTemporalLayers, paramData, sizeof(m_sParamTemporalLayers));
1510 // keep the config data in sync
1511 m_sConfigTemporalLayers.ePattern = m_sParamTemporalLayers.ePattern;
1512 m_sConfigTemporalLayers.nBLayerCountActual = m_sParamTemporalLayers.nBLayerCountActual;
1513 m_sConfigTemporalLayers.nPLayerCountActual = m_sParamTemporalLayers.nPLayerCountActual;
1514 m_sConfigTemporalLayers.bBitrateRatiosSpecified = m_sParamTemporalLayers.bBitrateRatiosSpecified;
1515 memcpy(&m_sConfigTemporalLayers.nBitrateRatios[0],
1516 &m_sParamTemporalLayers.nBitrateRatios[0],
1517 OMX_VIDEO_ANDROID_MAXTEMPORALLAYERS * sizeof(OMX_U32));
1518 break;
1519 }
1520 case OMX_IndexParamVideoSliceFMO:
1521 default:
1522 {
1523 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %d", paramIndex);
1524 eRet = OMX_ErrorUnsupportedIndex;
1525 break;
1526 }
1527 }
1528 return eRet;
1529 }
1530
update_profile_level()1531 bool omx_venc::update_profile_level()
1532 {
1533 OMX_U32 eProfile, eLevel;
1534
1535 if (!handle->venc_get_profile_level(&eProfile,&eLevel)) {
1536 DEBUG_PRINT_ERROR("Failed to update the profile_level");
1537 return false;
1538 }
1539
1540 m_sParamProfileLevel.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile;
1541 m_sParamProfileLevel.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel;
1542
1543 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\
1544 OMX_MAX_STRINGNAME_SIZE)) {
1545 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile;
1546 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel;
1547 DEBUG_PRINT_LOW("MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile,
1548 m_sParamMPEG4.eLevel);
1549 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\
1550 OMX_MAX_STRINGNAME_SIZE)) {
1551 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)eProfile;
1552 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)eLevel;
1553 DEBUG_PRINT_LOW("H263 profile = %d, level = %d", m_sParamH263.eProfile,
1554 m_sParamH263.eLevel);
1555 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
1556 OMX_MAX_STRINGNAME_SIZE)) {
1557 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile;
1558 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel;
1559 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1560 m_sParamAVC.eLevel);
1561 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
1562 OMX_MAX_STRINGNAME_SIZE)) {
1563 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile;
1564 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel;
1565 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1566 m_sParamAVC.eLevel);
1567 }
1568 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.vp8",\
1569 OMX_MAX_STRINGNAME_SIZE)) {
1570 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)eProfile;
1571 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)eLevel;
1572 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile,
1573 m_sParamVP8.eLevel);
1574 }
1575 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc",\
1576 OMX_MAX_STRINGNAME_SIZE)) {
1577 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)eProfile;
1578 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)eLevel;
1579 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile,
1580 m_sParamHEVC.eLevel);
1581 }
1582
1583 return true;
1584 }
1585 /* ======================================================================
1586 FUNCTION
1587 omx_video::SetConfig
1588
1589 DESCRIPTION
1590 OMX Set Config method implementation
1591
1592 PARAMETERS
1593 <TBD>.
1594
1595 RETURN VALUE
1596 OMX Error None if successful.
1597 ========================================================================== */
set_config(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_INDEXTYPE configIndex,OMX_IN OMX_PTR configData)1598 OMX_ERRORTYPE omx_venc::set_config(OMX_IN OMX_HANDLETYPE hComp,
1599 OMX_IN OMX_INDEXTYPE configIndex,
1600 OMX_IN OMX_PTR configData)
1601 {
1602 (void)hComp;
1603 if (configData == NULL) {
1604 DEBUG_PRINT_ERROR("ERROR: param is null");
1605 return OMX_ErrorBadParameter;
1606 }
1607
1608 if (m_state == OMX_StateInvalid) {
1609 DEBUG_PRINT_ERROR("ERROR: config called in Invalid state");
1610 return OMX_ErrorIncorrectStateOperation;
1611 }
1612
1613 // params will be validated prior to venc_init
1614 switch ((int)configIndex) {
1615 case OMX_IndexConfigVideoBitrate:
1616 {
1617 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_BITRATETYPE);
1618 OMX_VIDEO_CONFIG_BITRATETYPE* pParam =
1619 reinterpret_cast<OMX_VIDEO_CONFIG_BITRATETYPE*>(configData);
1620 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoBitrate (%u)", (unsigned int)pParam->nEncodeBitrate);
1621
1622 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1623 if (handle->venc_set_config(configData, OMX_IndexConfigVideoBitrate) != true) {
1624 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoBitrate failed");
1625 return OMX_ErrorUnsupportedSetting;
1626 }
1627
1628 m_sConfigBitrate.nEncodeBitrate = pParam->nEncodeBitrate;
1629 m_sParamBitrate.nTargetBitrate = pParam->nEncodeBitrate;
1630 m_sOutPortDef.format.video.nBitrate = pParam->nEncodeBitrate;
1631 } else {
1632 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1633 return OMX_ErrorBadPortIndex;
1634 }
1635 break;
1636 }
1637 case OMX_IndexConfigVideoFramerate:
1638 {
1639 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_FRAMERATETYPE);
1640 OMX_CONFIG_FRAMERATETYPE* pParam =
1641 reinterpret_cast<OMX_CONFIG_FRAMERATETYPE*>(configData);
1642 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoFramerate (0x%x)", (unsigned int)pParam->xEncodeFramerate);
1643
1644 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1645 if (handle->venc_set_config(configData, OMX_IndexConfigVideoFramerate) != true) {
1646 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoFramerate failed");
1647 return OMX_ErrorUnsupportedSetting;
1648 }
1649
1650 m_sConfigFramerate.xEncodeFramerate = pParam->xEncodeFramerate;
1651 m_sOutPortDef.format.video.xFramerate = pParam->xEncodeFramerate;
1652 m_sOutPortFormat.xFramerate = pParam->xEncodeFramerate;
1653 } else {
1654 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1655 return OMX_ErrorBadPortIndex;
1656 }
1657
1658 break;
1659 }
1660 case QOMX_IndexConfigVideoIntraperiod:
1661 {
1662 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_INTRAPERIODTYPE);
1663 QOMX_VIDEO_INTRAPERIODTYPE* pParam =
1664 reinterpret_cast<QOMX_VIDEO_INTRAPERIODTYPE*>(configData);
1665
1666 DEBUG_PRINT_HIGH("set_config(): QOMX_IndexConfigVideoIntraperiod");
1667 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1668 #ifdef MAX_RES_720P
1669 if (pParam->nBFrames > 0) {
1670 DEBUG_PRINT_ERROR("B frames not supported");
1671 return OMX_ErrorUnsupportedSetting;
1672 }
1673 #endif
1674 DEBUG_PRINT_HIGH("Old: P/B frames = %u/%u, New: P/B frames = %u/%u",
1675 (unsigned int)m_sIntraperiod.nPFrames, (unsigned int)m_sIntraperiod.nBFrames,
1676 (unsigned int)pParam->nPFrames, (unsigned int)pParam->nBFrames);
1677 if (m_sIntraperiod.nBFrames != pParam->nBFrames) {
1678 if(hier_b_enabled && m_state == OMX_StateLoaded) {
1679 DEBUG_PRINT_INFO("B-frames setting is supported if HierB is enabled");
1680 }
1681 else {
1682 DEBUG_PRINT_HIGH("Dynamically changing B-frames not supported");
1683 return OMX_ErrorUnsupportedSetting;
1684 }
1685 }
1686 if (handle->venc_set_config(configData, (OMX_INDEXTYPE) QOMX_IndexConfigVideoIntraperiod) != true) {
1687 DEBUG_PRINT_ERROR("ERROR: Setting QOMX_IndexConfigVideoIntraperiod failed");
1688 return OMX_ErrorUnsupportedSetting;
1689 }
1690 m_sIntraperiod.nPFrames = pParam->nPFrames;
1691 m_sIntraperiod.nBFrames = pParam->nBFrames;
1692 m_sIntraperiod.nIDRPeriod = pParam->nIDRPeriod;
1693
1694 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
1695 m_sParamMPEG4.nPFrames = pParam->nPFrames;
1696 if (m_sParamMPEG4.eProfile != OMX_VIDEO_MPEG4ProfileSimple)
1697 m_sParamMPEG4.nBFrames = pParam->nBFrames;
1698 else
1699 m_sParamMPEG4.nBFrames = 0;
1700 } else if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingH263) {
1701 m_sParamH263.nPFrames = pParam->nPFrames;
1702 } else {
1703 m_sParamAVC.nPFrames = pParam->nPFrames;
1704 if ((m_sParamAVC.eProfile != OMX_VIDEO_AVCProfileBaseline) &&
1705 (m_sParamAVC.eProfile != (OMX_VIDEO_AVCPROFILETYPE) QOMX_VIDEO_AVCProfileConstrainedBaseline))
1706 m_sParamAVC.nBFrames = pParam->nBFrames;
1707 else
1708 m_sParamAVC.nBFrames = 0;
1709 }
1710 } else {
1711 DEBUG_PRINT_ERROR("ERROR: (QOMX_IndexConfigVideoIntraperiod) Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1712 return OMX_ErrorBadPortIndex;
1713 }
1714
1715 break;
1716 }
1717
1718 case OMX_IndexConfigVideoIntraVOPRefresh:
1719 {
1720 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_INTRAREFRESHVOPTYPE);
1721 OMX_CONFIG_INTRAREFRESHVOPTYPE* pParam =
1722 reinterpret_cast<OMX_CONFIG_INTRAREFRESHVOPTYPE*>(configData);
1723
1724 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoIntraVOPRefresh");
1725 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1726 if (handle->venc_set_config(configData,
1727 OMX_IndexConfigVideoIntraVOPRefresh) != true) {
1728 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoIntraVOPRefresh failed");
1729 return OMX_ErrorUnsupportedSetting;
1730 }
1731
1732 m_sConfigIntraRefreshVOP.IntraRefreshVOP = pParam->IntraRefreshVOP;
1733 } else {
1734 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1735 return OMX_ErrorBadPortIndex;
1736 }
1737
1738 break;
1739 }
1740 case OMX_IndexConfigCommonRotate:
1741 {
1742 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ROTATIONTYPE);
1743 OMX_CONFIG_ROTATIONTYPE *pParam =
1744 reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData);
1745 OMX_S32 nRotation;
1746
1747 if (pParam->nPortIndex != PORT_INDEX_OUT) {
1748 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1749 return OMX_ErrorBadPortIndex;
1750 }
1751 if ( pParam->nRotation == 0 ||
1752 pParam->nRotation == 90 ||
1753 pParam->nRotation == 180 ||
1754 pParam->nRotation == 270 ) {
1755 DEBUG_PRINT_HIGH("set_config: Rotation Angle %u", (unsigned int)pParam->nRotation);
1756 } else {
1757 DEBUG_PRINT_ERROR("ERROR: un supported Rotation %u", (unsigned int)pParam->nRotation);
1758 return OMX_ErrorUnsupportedSetting;
1759 }
1760 nRotation = pParam->nRotation - m_sConfigFrameRotation.nRotation;
1761 if (nRotation < 0)
1762 nRotation = -nRotation;
1763 if (nRotation == 90 || nRotation == 270) {
1764 DEBUG_PRINT_HIGH("set_config: updating device Dims");
1765 if (handle->venc_set_config(configData,
1766 OMX_IndexConfigCommonRotate) != true) {
1767 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonRotate failed");
1768 return OMX_ErrorUnsupportedSetting;
1769 } else {
1770 OMX_U32 nFrameWidth;
1771 OMX_U32 nFrameHeight;
1772
1773 DEBUG_PRINT_HIGH("set_config: updating port Dims");
1774
1775 nFrameWidth = m_sOutPortDef.format.video.nFrameWidth;
1776 nFrameHeight = m_sOutPortDef.format.video.nFrameHeight;
1777 m_sOutPortDef.format.video.nFrameWidth = nFrameHeight;
1778 m_sOutPortDef.format.video.nFrameHeight = nFrameWidth;
1779 m_sConfigFrameRotation.nRotation = pParam->nRotation;
1780 }
1781 } else {
1782 m_sConfigFrameRotation.nRotation = pParam->nRotation;
1783 }
1784 break;
1785 }
1786 case OMX_QcomIndexConfigVideoFramePackingArrangement:
1787 {
1788 DEBUG_PRINT_HIGH("set_config(): OMX_QcomIndexConfigVideoFramePackingArrangement");
1789 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingAVC) {
1790 VALIDATE_OMX_PARAM_DATA(configData, OMX_QCOM_FRAME_PACK_ARRANGEMENT);
1791 OMX_QCOM_FRAME_PACK_ARRANGEMENT *configFmt =
1792 (OMX_QCOM_FRAME_PACK_ARRANGEMENT *) configData;
1793 extra_data_handle.set_frame_pack_data(configFmt);
1794 } else {
1795 DEBUG_PRINT_ERROR("ERROR: FramePackingData not supported for non AVC compression");
1796 }
1797 break;
1798 }
1799 case QOMX_IndexConfigVideoLTRPeriod:
1800 {
1801 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE);
1802 QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE*)configData;
1803 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRPeriod)) {
1804 DEBUG_PRINT_ERROR("ERROR: Setting LTR period failed");
1805 return OMX_ErrorUnsupportedSetting;
1806 }
1807 memcpy(&m_sConfigLTRPeriod, pParam, sizeof(m_sConfigLTRPeriod));
1808 break;
1809 }
1810
1811 case OMX_IndexConfigVideoVp8ReferenceFrame:
1812 {
1813 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_VP8REFERENCEFRAMETYPE);
1814 OMX_VIDEO_VP8REFERENCEFRAMETYPE* pParam = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*) configData;
1815 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE) OMX_IndexConfigVideoVp8ReferenceFrame)) {
1816 DEBUG_PRINT_ERROR("ERROR: Setting VP8 reference frame");
1817 return OMX_ErrorUnsupportedSetting;
1818 }
1819 memcpy(&m_sConfigVp8ReferenceFrame, pParam, sizeof(m_sConfigVp8ReferenceFrame));
1820 break;
1821 }
1822
1823 case QOMX_IndexConfigVideoLTRUse:
1824 {
1825 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRUSE_TYPE);
1826 QOMX_VIDEO_CONFIG_LTRUSE_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRUSE_TYPE*)configData;
1827 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRUse)) {
1828 DEBUG_PRINT_ERROR("ERROR: Setting LTR use failed");
1829 return OMX_ErrorUnsupportedSetting;
1830 }
1831 memcpy(&m_sConfigLTRUse, pParam, sizeof(m_sConfigLTRUse));
1832 break;
1833 }
1834 case QOMX_IndexConfigVideoLTRMark:
1835 {
1836 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRMARK_TYPE);
1837 QOMX_VIDEO_CONFIG_LTRMARK_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRMARK_TYPE*)configData;
1838 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRMark)) {
1839 DEBUG_PRINT_ERROR("ERROR: Setting LTR mark failed");
1840 return OMX_ErrorUnsupportedSetting;
1841 }
1842 break;
1843 }
1844 case OMX_IndexConfigVideoAVCIntraPeriod:
1845 {
1846 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_AVCINTRAPERIOD);
1847 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pParam = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD*) configData;
1848 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigVideoAVCIntraPeriod");
1849 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigVideoAVCIntraPeriod)) {
1850 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoAVCIntraPeriod failed");
1851 return OMX_ErrorUnsupportedSetting;
1852 }
1853 memcpy(&m_sConfigAVCIDRPeriod, pParam, sizeof(m_sConfigAVCIDRPeriod));
1854 break;
1855 }
1856 case OMX_IndexConfigCommonDeinterlace:
1857 {
1858 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_DEINTERLACE);
1859 OMX_VIDEO_CONFIG_DEINTERLACE *pParam = (OMX_VIDEO_CONFIG_DEINTERLACE*) configData;
1860 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigCommonDeinterlace");
1861 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigCommonDeinterlace)) {
1862 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigCommonDeinterlace failed");
1863 return OMX_ErrorUnsupportedSetting;
1864 }
1865 memcpy(&m_sConfigDeinterlace, pParam, sizeof(m_sConfigDeinterlace));
1866 break;
1867 }
1868 case OMX_QcomIndexConfigVideoVencPerfMode:
1869 {
1870 VALIDATE_OMX_PARAM_DATA(configData, QOMX_EXTNINDEX_VIDEO_PERFMODE);
1871 QOMX_EXTNINDEX_VIDEO_PERFMODE* pParam = (QOMX_EXTNINDEX_VIDEO_PERFMODE*)configData;
1872 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode)) {
1873 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigVideoVencPerfMode failed");
1874 return OMX_ErrorUnsupportedSetting;
1875 }
1876 break;
1877 }
1878 case OMX_IndexConfigPriority:
1879 {
1880 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
1881 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigPriority)) {
1882 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigPriority");
1883 return OMX_ErrorUnsupportedSetting;
1884 }
1885 break;
1886 }
1887 case OMX_IndexConfigOperatingRate:
1888 {
1889 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
1890 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigOperatingRate)) {
1891 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigOperatingRate");
1892 return handle->hw_overload ? OMX_ErrorInsufficientResources :
1893 OMX_ErrorUnsupportedSetting;
1894 }
1895 break;
1896 }
1897 case OMX_IndexConfigAndroidIntraRefresh:
1898 {
1899 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE);
1900 OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE* pParam =
1901 (OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE*) configData;
1902 if (m_state == OMX_StateLoaded
1903 || m_sInPortDef.bEnabled == OMX_FALSE
1904 || m_sOutPortDef.bEnabled == OMX_FALSE) {
1905 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh)) {
1906 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigVideoIntraRefreshType");
1907 return OMX_ErrorUnsupportedSetting;
1908 }
1909 m_sConfigIntraRefresh.nRefreshPeriod = pParam->nRefreshPeriod;
1910 } else {
1911 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigAndroidIntraRefresh supported only at start of session");
1912 return OMX_ErrorUnsupportedSetting;
1913 }
1914 break;
1915 }
1916 default:
1917 DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex);
1918 break;
1919 }
1920
1921 return OMX_ErrorNone;
1922 }
1923
1924 /* ======================================================================
1925 FUNCTION
1926 omx_venc::ComponentDeInit
1927
1928 DESCRIPTION
1929 Destroys the component and release memory allocated to the heap.
1930
1931 PARAMETERS
1932 <TBD>.
1933
1934 RETURN VALUE
1935 OMX Error None if everything successful.
1936
1937 ========================================================================== */
component_deinit(OMX_IN OMX_HANDLETYPE hComp)1938 OMX_ERRORTYPE omx_venc::component_deinit(OMX_IN OMX_HANDLETYPE hComp)
1939 {
1940 (void) hComp;
1941 OMX_U32 i = 0;
1942 DEBUG_PRINT_HIGH("omx_venc(): Inside component_deinit()");
1943 if (OMX_StateLoaded != m_state) {
1944 DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d",\
1945 m_state);
1946 }
1947 if (m_out_mem_ptr) {
1948 DEBUG_PRINT_LOW("Freeing the Output Memory");
1949 for (i=0; i< m_sOutPortDef.nBufferCountActual; i++ ) {
1950 if (BITMASK_PRESENT(&m_out_bm_count, i)) {
1951 BITMASK_CLEAR(&m_out_bm_count, i);
1952 free_output_buffer (&m_out_mem_ptr[i]);
1953 }
1954
1955 if (release_output_done()) {
1956 break;
1957 }
1958 }
1959 free(m_out_mem_ptr);
1960 m_out_mem_ptr = NULL;
1961 }
1962
1963 /*Check if the input buffers have to be cleaned up*/
1964 if (m_inp_mem_ptr
1965 #ifdef _ANDROID_ICS_
1966 && !meta_mode_enable
1967 #endif
1968 ) {
1969 DEBUG_PRINT_LOW("Freeing the Input Memory");
1970 for (i=0; i<m_sInPortDef.nBufferCountActual; i++ ) {
1971 if (BITMASK_PRESENT(&m_inp_bm_count, i)) {
1972 BITMASK_CLEAR(&m_inp_bm_count, i);
1973 free_input_buffer (&m_inp_mem_ptr[i]);
1974 }
1975
1976 if (release_input_done()) {
1977 break;
1978 }
1979 }
1980
1981
1982 free(m_inp_mem_ptr);
1983 m_inp_mem_ptr = NULL;
1984 }
1985
1986 // Reset counters in mesg queues
1987 m_ftb_q.m_size=0;
1988 m_cmd_q.m_size=0;
1989 m_etb_q.m_size=0;
1990 m_ftb_q.m_read = m_ftb_q.m_write =0;
1991 m_cmd_q.m_read = m_cmd_q.m_write =0;
1992 m_etb_q.m_read = m_etb_q.m_write =0;
1993
1994 #ifdef _ANDROID_
1995 // Clear the strong reference
1996 DEBUG_PRINT_HIGH("Calling m_heap_ptr.clear()");
1997 m_heap_ptr.clear();
1998 #endif // _ANDROID_
1999 DEBUG_PRINT_HIGH("Calling venc_close()");
2000 if (handle) {
2001 handle->venc_close();
2002 DEBUG_PRINT_HIGH("Deleting HANDLE[%p]", handle);
2003 delete (handle);
2004 handle = NULL;
2005 }
2006 DEBUG_PRINT_INFO("Component Deinit");
2007 return OMX_ErrorNone;
2008 }
2009
2010
dev_stop(void)2011 OMX_U32 omx_venc::dev_stop( void)
2012 {
2013 return handle->venc_stop();
2014 }
2015
2016
dev_pause(void)2017 OMX_U32 omx_venc::dev_pause(void)
2018 {
2019 return handle->venc_pause();
2020 }
2021
dev_start(void)2022 OMX_U32 omx_venc::dev_start(void)
2023 {
2024 return handle->venc_start();
2025 }
2026
dev_flush(unsigned port)2027 OMX_U32 omx_venc::dev_flush(unsigned port)
2028 {
2029 return handle->venc_flush(port);
2030 }
dev_resume(void)2031 OMX_U32 omx_venc::dev_resume(void)
2032 {
2033 return handle->venc_resume();
2034 }
2035
dev_start_done(void)2036 OMX_U32 omx_venc::dev_start_done(void)
2037 {
2038 return handle->venc_start_done();
2039 }
2040
dev_set_message_thread_id(pthread_t tid)2041 OMX_U32 omx_venc::dev_set_message_thread_id(pthread_t tid)
2042 {
2043 return handle->venc_set_message_thread_id(tid);
2044 }
2045
dev_use_buf(void * buf_addr,unsigned port,unsigned index)2046 bool omx_venc::dev_use_buf(void *buf_addr,unsigned port,unsigned index)
2047 {
2048 return handle->venc_use_buf(buf_addr,port,index);
2049 }
2050
dev_free_buf(void * buf_addr,unsigned port)2051 bool omx_venc::dev_free_buf(void *buf_addr,unsigned port)
2052 {
2053 return handle->venc_free_buf(buf_addr,port);
2054 }
2055
dev_empty_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2056 bool omx_venc::dev_empty_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2057 {
2058 bool bret = false;
2059 bret = handle->venc_empty_buf(buffer, pmem_data_buf,index,fd);
2060 hw_overload = handle->hw_overload;
2061 return bret;
2062 }
2063
dev_fill_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2064 bool omx_venc::dev_fill_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2065 {
2066 return handle->venc_fill_buf(buffer, pmem_data_buf,index,fd);
2067 }
2068
dev_get_seq_hdr(void * buffer,unsigned size,unsigned * hdrlen)2069 bool omx_venc::dev_get_seq_hdr(void *buffer, unsigned size, unsigned *hdrlen)
2070 {
2071 return handle->venc_get_seq_hdr(buffer, size, hdrlen);
2072 }
2073
dev_get_capability_ltrcount(OMX_U32 * min,OMX_U32 * max,OMX_U32 * step_size)2074 bool omx_venc::dev_get_capability_ltrcount(OMX_U32 *min, OMX_U32 *max, OMX_U32 *step_size)
2075 {
2076 #ifdef _MSM8974_
2077 (void) min;
2078 (void) max;
2079 (void) step_size;
2080 DEBUG_PRINT_ERROR("Get Capability LTR Count is not supported");
2081 return false;
2082 #else
2083 return handle->venc_get_capability_ltrcount(min, max, step_size);
2084 #endif
2085 }
2086
dev_get_performance_level(OMX_U32 * perflevel)2087 bool omx_venc::dev_get_performance_level(OMX_U32 *perflevel)
2088 {
2089 #ifdef _MSM8974_
2090 return handle->venc_get_performance_level(perflevel);
2091 #else
2092 DEBUG_PRINT_ERROR("Get performance level is not supported");
2093 return false;
2094 #endif
2095 }
2096
dev_get_vui_timing_info(OMX_U32 * enabled)2097 bool omx_venc::dev_get_vui_timing_info(OMX_U32 *enabled)
2098 {
2099 #ifdef _MSM8974_
2100 return handle->venc_get_vui_timing_info(enabled);
2101 #else
2102 DEBUG_PRINT_ERROR("Get vui timing information is not supported");
2103 return false;
2104 #endif
2105 }
2106
dev_get_peak_bitrate(OMX_U32 * peakbitrate)2107 bool omx_venc::dev_get_peak_bitrate(OMX_U32 *peakbitrate)
2108 {
2109 #ifdef _MSM8974_
2110 return handle->venc_get_peak_bitrate(peakbitrate);
2111 #else
2112 DEBUG_PRINT_ERROR("Get peak bitrate is not supported");
2113 return false;
2114 #endif
2115 }
2116
dev_get_temporal_layer_caps(OMX_U32 * nMaxLayers,OMX_U32 * nMaxBLayers)2117 bool omx_venc::dev_get_temporal_layer_caps(OMX_U32 *nMaxLayers,
2118 OMX_U32 *nMaxBLayers) {
2119 return handle->venc_get_temporal_layer_caps(nMaxLayers, nMaxBLayers);
2120 }
2121
dev_loaded_start()2122 bool omx_venc::dev_loaded_start()
2123 {
2124 return handle->venc_loaded_start();
2125 }
2126
dev_loaded_stop()2127 bool omx_venc::dev_loaded_stop()
2128 {
2129 return handle->venc_loaded_stop();
2130 }
2131
dev_loaded_start_done()2132 bool omx_venc::dev_loaded_start_done()
2133 {
2134 return handle->venc_loaded_start_done();
2135 }
2136
dev_loaded_stop_done()2137 bool omx_venc::dev_loaded_stop_done()
2138 {
2139 return handle->venc_loaded_stop_done();
2140 }
2141
dev_get_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2142 bool omx_venc::dev_get_buf_req(OMX_U32 *min_buff_count,
2143 OMX_U32 *actual_buff_count,
2144 OMX_U32 *buff_size,
2145 OMX_U32 port)
2146 {
2147 return handle->venc_get_buf_req(min_buff_count,
2148 actual_buff_count,
2149 buff_size,
2150 port);
2151
2152 }
2153
dev_set_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2154 bool omx_venc::dev_set_buf_req(OMX_U32 *min_buff_count,
2155 OMX_U32 *actual_buff_count,
2156 OMX_U32 *buff_size,
2157 OMX_U32 port)
2158 {
2159 return handle->venc_set_buf_req(min_buff_count,
2160 actual_buff_count,
2161 buff_size,
2162 port);
2163
2164 }
2165
dev_is_video_session_supported(OMX_U32 width,OMX_U32 height)2166 bool omx_venc::dev_is_video_session_supported(OMX_U32 width, OMX_U32 height)
2167 {
2168 #ifdef _MSM8974_
2169 return handle->venc_is_video_session_supported(width,height);
2170 #else
2171 DEBUG_PRINT_LOW("Check against video capability not supported");
2172 return true;
2173 #endif
2174 }
2175
2176 #ifdef _MSM8974_
dev_handle_extradata(void * buffer,int index)2177 int omx_venc::dev_handle_extradata(void *buffer, int index)
2178 {
2179 return handle->handle_extradata(buffer, index);
2180 }
2181
dev_set_format(int color)2182 int omx_venc::dev_set_format(int color)
2183 {
2184 return handle->venc_set_format(color);
2185 }
2186 #endif
2187
async_message_process(void * context,void * message)2188 int omx_venc::async_message_process (void *context, void* message)
2189 {
2190 omx_video* omx = NULL;
2191 struct venc_msg *m_sVenc_msg = NULL;
2192 OMX_BUFFERHEADERTYPE* omxhdr = NULL;
2193 struct venc_buffer *temp_buff = NULL;
2194
2195 if (context == NULL || message == NULL) {
2196 DEBUG_PRINT_ERROR("ERROR: omx_venc::async_message_process invalid i/p params");
2197 return -1;
2198 }
2199 m_sVenc_msg = (struct venc_msg *)message;
2200
2201 omx = reinterpret_cast<omx_video*>(context);
2202
2203 if (m_sVenc_msg->statuscode != VEN_S_SUCCESS) {
2204 DEBUG_PRINT_ERROR("ERROR: async_msg_process() - Error statuscode = %lu",
2205 m_sVenc_msg->statuscode);
2206 if(m_sVenc_msg->msgcode == VEN_MSG_HW_OVERLOAD) {
2207 omx->omx_report_hw_overload();
2208 } else
2209 omx->omx_report_error();
2210 }
2211
2212 DEBUG_PRINT_LOW("omx_venc::async_message_process- msgcode = %lu",
2213 m_sVenc_msg->msgcode);
2214 switch (m_sVenc_msg->msgcode) {
2215 case VEN_MSG_START:
2216 omx->post_event (0,m_sVenc_msg->statuscode,\
2217 OMX_COMPONENT_GENERATE_START_DONE);
2218 break;
2219 case VEN_MSG_STOP:
2220 omx->post_event (0,m_sVenc_msg->statuscode,\
2221 OMX_COMPONENT_GENERATE_STOP_DONE);
2222 break;
2223 case VEN_MSG_RESUME:
2224 omx->post_event (0,m_sVenc_msg->statuscode,\
2225 OMX_COMPONENT_GENERATE_RESUME_DONE);
2226 break;
2227 case VEN_MSG_PAUSE:
2228 omx->post_event (0,m_sVenc_msg->statuscode,\
2229 OMX_COMPONENT_GENERATE_PAUSE_DONE);
2230 break;
2231 case VEN_MSG_FLUSH_INPUT_DONE:
2232
2233 omx->post_event (0,m_sVenc_msg->statuscode,\
2234 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH);
2235 break;
2236 case VEN_MSG_FLUSH_OUPUT_DONE:
2237 omx->post_event (0,m_sVenc_msg->statuscode,\
2238 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH);
2239 break;
2240 case VEN_MSG_INPUT_BUFFER_DONE:
2241 omxhdr = (OMX_BUFFERHEADERTYPE* )\
2242 m_sVenc_msg->buf.clientdata;
2243
2244 if (omxhdr == NULL ||
2245 (((OMX_U32)(omxhdr - omx->m_inp_mem_ptr) > omx->m_sInPortDef.nBufferCountActual) &&
2246 ((OMX_U32)(omxhdr - omx->meta_buffer_hdr) > omx->m_sInPortDef.nBufferCountActual))) {
2247 omxhdr = NULL;
2248 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2249 }
2250
2251 #ifdef _ANDROID_ICS_
2252 omx->omx_release_meta_buffer(omxhdr);
2253 #endif
2254 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2255 OMX_COMPONENT_GENERATE_EBD);
2256 break;
2257 case VEN_MSG_OUTPUT_BUFFER_DONE:
2258 omxhdr = (OMX_BUFFERHEADERTYPE*)m_sVenc_msg->buf.clientdata;
2259
2260 if ( (omxhdr != NULL) &&
2261 ((OMX_U32)(omxhdr - omx->m_out_mem_ptr) < omx->m_sOutPortDef.nBufferCountActual)) {
2262 if (m_sVenc_msg->buf.len <= omxhdr->nAllocLen) {
2263 omxhdr->nFilledLen = m_sVenc_msg->buf.len;
2264 omxhdr->nOffset = m_sVenc_msg->buf.offset;
2265 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2266 DEBUG_PRINT_LOW("o/p TS = %u", (unsigned int)m_sVenc_msg->buf.timestamp);
2267 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2268
2269 /*Use buffer case*/
2270 if (omx->output_use_buffer && !omx->m_use_output_pmem && !omx->is_secure_session()) {
2271 DEBUG_PRINT_LOW("memcpy() for o/p Heap UseBuffer");
2272 memcpy(omxhdr->pBuffer,
2273 (m_sVenc_msg->buf.ptrbuffer),
2274 m_sVenc_msg->buf.len);
2275 }
2276 } else {
2277 omxhdr->nFilledLen = 0;
2278 }
2279
2280 } else {
2281 omxhdr = NULL;
2282 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2283 }
2284 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2285 OMX_COMPONENT_GENERATE_FBD);
2286 break;
2287 case VEN_MSG_NEED_OUTPUT_BUFFER:
2288 //TBD what action needs to be done here??
2289 break;
2290 #ifndef _MSM8974_
2291 case VEN_MSG_LTRUSE_FAILED:
2292 DEBUG_PRINT_ERROR("LTRUSE Failed!");
2293 omx->post_event (NULL,m_sVenc_msg->statuscode,
2294 OMX_COMPONENT_GENERATE_LTRUSE_FAILED);
2295 break;
2296 #endif
2297 default:
2298 DEBUG_PRINT_HIGH("Unknown msg received : %lu", m_sVenc_msg->msgcode);
2299 break;
2300 }
2301 return 0;
2302 }
2303
dev_color_align(OMX_BUFFERHEADERTYPE * buffer,OMX_U32 width,OMX_U32 height)2304 bool omx_venc::dev_color_align(OMX_BUFFERHEADERTYPE *buffer,
2305 OMX_U32 width, OMX_U32 height)
2306 {
2307 if(secure_session) {
2308 DEBUG_PRINT_ERROR("Cannot align colors in secure session.");
2309 return OMX_FALSE;
2310 }
2311 return handle->venc_color_align(buffer, width,height);
2312 }
2313
is_secure_session()2314 bool omx_venc::is_secure_session()
2315 {
2316 return secure_session;
2317 }
2318
dev_get_output_log_flag()2319 bool omx_venc::dev_get_output_log_flag()
2320 {
2321 return handle->venc_get_output_log_flag();
2322 }
2323
dev_output_log_buffers(const char * buffer,int bufferlen)2324 int omx_venc::dev_output_log_buffers(const char *buffer, int bufferlen)
2325 {
2326 return handle->venc_output_log_buffers(buffer, bufferlen);
2327 }
2328
dev_extradata_log_buffers(char * buffer)2329 int omx_venc::dev_extradata_log_buffers(char *buffer)
2330 {
2331 return handle->venc_extradata_log_buffers(buffer);
2332 }
2333