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