1 /*--------------------------------------------------------------------------
2 Copyright (c) 2010-2017, 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) OMX_VIDEO_AVCProfileConstrainedBaseline) &&
1706 (m_sParamAVC.eProfile != (OMX_VIDEO_AVCPROFILETYPE) QOMX_VIDEO_AVCProfileConstrainedBaseline))
1707 m_sParamAVC.nBFrames = pParam->nBFrames;
1708 else
1709 m_sParamAVC.nBFrames = 0;
1710 }
1711 } else {
1712 DEBUG_PRINT_ERROR("ERROR: (QOMX_IndexConfigVideoIntraperiod) Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1713 return OMX_ErrorBadPortIndex;
1714 }
1715
1716 break;
1717 }
1718
1719 case OMX_IndexConfigVideoIntraVOPRefresh:
1720 {
1721 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_INTRAREFRESHVOPTYPE);
1722 OMX_CONFIG_INTRAREFRESHVOPTYPE* pParam =
1723 reinterpret_cast<OMX_CONFIG_INTRAREFRESHVOPTYPE*>(configData);
1724
1725 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoIntraVOPRefresh");
1726 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1727 if (handle->venc_set_config(configData,
1728 OMX_IndexConfigVideoIntraVOPRefresh) != true) {
1729 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoIntraVOPRefresh failed");
1730 return OMX_ErrorUnsupportedSetting;
1731 }
1732
1733 m_sConfigIntraRefreshVOP.IntraRefreshVOP = pParam->IntraRefreshVOP;
1734 } else {
1735 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1736 return OMX_ErrorBadPortIndex;
1737 }
1738
1739 break;
1740 }
1741 case OMX_IndexConfigCommonRotate:
1742 {
1743 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ROTATIONTYPE);
1744 OMX_CONFIG_ROTATIONTYPE *pParam =
1745 reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData);
1746 OMX_S32 nRotation;
1747
1748 if (pParam->nPortIndex != PORT_INDEX_OUT) {
1749 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1750 return OMX_ErrorBadPortIndex;
1751 }
1752 if ( pParam->nRotation == 0 ||
1753 pParam->nRotation == 90 ||
1754 pParam->nRotation == 180 ||
1755 pParam->nRotation == 270 ) {
1756 DEBUG_PRINT_HIGH("set_config: Rotation Angle %u", (unsigned int)pParam->nRotation);
1757 } else {
1758 DEBUG_PRINT_ERROR("ERROR: un supported Rotation %u", (unsigned int)pParam->nRotation);
1759 return OMX_ErrorUnsupportedSetting;
1760 }
1761 nRotation = pParam->nRotation - m_sConfigFrameRotation.nRotation;
1762 if (nRotation < 0)
1763 nRotation = -nRotation;
1764 if (nRotation == 90 || nRotation == 270) {
1765 DEBUG_PRINT_HIGH("set_config: updating device Dims");
1766 if (handle->venc_set_config(configData,
1767 OMX_IndexConfigCommonRotate) != true) {
1768 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonRotate failed");
1769 return OMX_ErrorUnsupportedSetting;
1770 } else {
1771 OMX_U32 nFrameWidth;
1772 OMX_U32 nFrameHeight;
1773
1774 DEBUG_PRINT_HIGH("set_config: updating port Dims");
1775
1776 nFrameWidth = m_sOutPortDef.format.video.nFrameWidth;
1777 nFrameHeight = m_sOutPortDef.format.video.nFrameHeight;
1778 m_sOutPortDef.format.video.nFrameWidth = nFrameHeight;
1779 m_sOutPortDef.format.video.nFrameHeight = nFrameWidth;
1780 m_sConfigFrameRotation.nRotation = pParam->nRotation;
1781 }
1782 } else {
1783 m_sConfigFrameRotation.nRotation = pParam->nRotation;
1784 }
1785 break;
1786 }
1787 case OMX_QcomIndexConfigVideoFramePackingArrangement:
1788 {
1789 DEBUG_PRINT_HIGH("set_config(): OMX_QcomIndexConfigVideoFramePackingArrangement");
1790 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingAVC) {
1791 VALIDATE_OMX_PARAM_DATA(configData, OMX_QCOM_FRAME_PACK_ARRANGEMENT);
1792 OMX_QCOM_FRAME_PACK_ARRANGEMENT *configFmt =
1793 (OMX_QCOM_FRAME_PACK_ARRANGEMENT *) configData;
1794 extra_data_handle.set_frame_pack_data(configFmt);
1795 } else {
1796 DEBUG_PRINT_ERROR("ERROR: FramePackingData not supported for non AVC compression");
1797 }
1798 break;
1799 }
1800 case QOMX_IndexConfigVideoLTRPeriod:
1801 {
1802 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE);
1803 QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE*)configData;
1804 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRPeriod)) {
1805 DEBUG_PRINT_ERROR("ERROR: Setting LTR period failed");
1806 return OMX_ErrorUnsupportedSetting;
1807 }
1808 memcpy(&m_sConfigLTRPeriod, pParam, sizeof(m_sConfigLTRPeriod));
1809 break;
1810 }
1811
1812 case OMX_IndexConfigVideoVp8ReferenceFrame:
1813 {
1814 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_VP8REFERENCEFRAMETYPE);
1815 OMX_VIDEO_VP8REFERENCEFRAMETYPE* pParam = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*) configData;
1816 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE) OMX_IndexConfigVideoVp8ReferenceFrame)) {
1817 DEBUG_PRINT_ERROR("ERROR: Setting VP8 reference frame");
1818 return OMX_ErrorUnsupportedSetting;
1819 }
1820 memcpy(&m_sConfigVp8ReferenceFrame, pParam, sizeof(m_sConfigVp8ReferenceFrame));
1821 break;
1822 }
1823
1824 case QOMX_IndexConfigVideoLTRUse:
1825 {
1826 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRUSE_TYPE);
1827 QOMX_VIDEO_CONFIG_LTRUSE_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRUSE_TYPE*)configData;
1828 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRUse)) {
1829 DEBUG_PRINT_ERROR("ERROR: Setting LTR use failed");
1830 return OMX_ErrorUnsupportedSetting;
1831 }
1832 memcpy(&m_sConfigLTRUse, pParam, sizeof(m_sConfigLTRUse));
1833 break;
1834 }
1835 case QOMX_IndexConfigVideoLTRMark:
1836 {
1837 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRMARK_TYPE);
1838 QOMX_VIDEO_CONFIG_LTRMARK_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRMARK_TYPE*)configData;
1839 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRMark)) {
1840 DEBUG_PRINT_ERROR("ERROR: Setting LTR mark failed");
1841 return OMX_ErrorUnsupportedSetting;
1842 }
1843 break;
1844 }
1845 case OMX_IndexConfigVideoAVCIntraPeriod:
1846 {
1847 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_AVCINTRAPERIOD);
1848 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pParam = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD*) configData;
1849 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigVideoAVCIntraPeriod");
1850 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigVideoAVCIntraPeriod)) {
1851 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoAVCIntraPeriod failed");
1852 return OMX_ErrorUnsupportedSetting;
1853 }
1854 memcpy(&m_sConfigAVCIDRPeriod, pParam, sizeof(m_sConfigAVCIDRPeriod));
1855 break;
1856 }
1857 case OMX_IndexConfigCommonDeinterlace:
1858 {
1859 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_DEINTERLACE);
1860 OMX_VIDEO_CONFIG_DEINTERLACE *pParam = (OMX_VIDEO_CONFIG_DEINTERLACE*) configData;
1861 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigCommonDeinterlace");
1862 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigCommonDeinterlace)) {
1863 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigCommonDeinterlace failed");
1864 return OMX_ErrorUnsupportedSetting;
1865 }
1866 memcpy(&m_sConfigDeinterlace, pParam, sizeof(m_sConfigDeinterlace));
1867 break;
1868 }
1869 case OMX_QcomIndexConfigVideoVencPerfMode:
1870 {
1871 VALIDATE_OMX_PARAM_DATA(configData, QOMX_EXTNINDEX_VIDEO_PERFMODE);
1872 QOMX_EXTNINDEX_VIDEO_PERFMODE* pParam = (QOMX_EXTNINDEX_VIDEO_PERFMODE*)configData;
1873 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode)) {
1874 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigVideoVencPerfMode failed");
1875 return OMX_ErrorUnsupportedSetting;
1876 }
1877 break;
1878 }
1879 case OMX_IndexConfigPriority:
1880 {
1881 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
1882 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigPriority)) {
1883 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigPriority");
1884 return OMX_ErrorUnsupportedSetting;
1885 }
1886 break;
1887 }
1888 case OMX_IndexConfigOperatingRate:
1889 {
1890 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
1891 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigOperatingRate)) {
1892 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigOperatingRate");
1893 return handle->hw_overload ? OMX_ErrorInsufficientResources :
1894 OMX_ErrorUnsupportedSetting;
1895 }
1896 break;
1897 }
1898 case OMX_IndexConfigAndroidIntraRefresh:
1899 {
1900 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE);
1901 OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE* pParam =
1902 (OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE*) configData;
1903 if (m_state == OMX_StateLoaded
1904 || m_sInPortDef.bEnabled == OMX_FALSE
1905 || m_sOutPortDef.bEnabled == OMX_FALSE) {
1906 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh)) {
1907 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigVideoIntraRefreshType");
1908 return OMX_ErrorUnsupportedSetting;
1909 }
1910 m_sConfigIntraRefresh.nRefreshPeriod = pParam->nRefreshPeriod;
1911 } else {
1912 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigAndroidIntraRefresh supported only at start of session");
1913 return OMX_ErrorUnsupportedSetting;
1914 }
1915 break;
1916 }
1917 default:
1918 DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex);
1919 break;
1920 }
1921
1922 return OMX_ErrorNone;
1923 }
1924
1925 /* ======================================================================
1926 FUNCTION
1927 omx_venc::ComponentDeInit
1928
1929 DESCRIPTION
1930 Destroys the component and release memory allocated to the heap.
1931
1932 PARAMETERS
1933 <TBD>.
1934
1935 RETURN VALUE
1936 OMX Error None if everything successful.
1937
1938 ========================================================================== */
component_deinit(OMX_IN OMX_HANDLETYPE hComp)1939 OMX_ERRORTYPE omx_venc::component_deinit(OMX_IN OMX_HANDLETYPE hComp)
1940 {
1941 (void) hComp;
1942 OMX_U32 i = 0;
1943 DEBUG_PRINT_HIGH("omx_venc(): Inside component_deinit()");
1944 if (OMX_StateLoaded != m_state) {
1945 DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d",\
1946 m_state);
1947 }
1948 if (m_out_mem_ptr) {
1949 DEBUG_PRINT_LOW("Freeing the Output Memory");
1950 for (i=0; i< m_sOutPortDef.nBufferCountActual; i++ ) {
1951 if (BITMASK_PRESENT(&m_out_bm_count, i)) {
1952 BITMASK_CLEAR(&m_out_bm_count, i);
1953 free_output_buffer (&m_out_mem_ptr[i]);
1954 }
1955
1956 if (release_output_done()) {
1957 break;
1958 }
1959 }
1960 free(m_out_mem_ptr);
1961 m_out_mem_ptr = NULL;
1962 }
1963
1964 /*Check if the input buffers have to be cleaned up*/
1965 if (m_inp_mem_ptr
1966 #ifdef _ANDROID_ICS_
1967 && !meta_mode_enable
1968 #endif
1969 ) {
1970 DEBUG_PRINT_LOW("Freeing the Input Memory");
1971 for (i=0; i<m_sInPortDef.nBufferCountActual; i++ ) {
1972 if (BITMASK_PRESENT(&m_inp_bm_count, i)) {
1973 BITMASK_CLEAR(&m_inp_bm_count, i);
1974 free_input_buffer (&m_inp_mem_ptr[i]);
1975 }
1976
1977 if (release_input_done()) {
1978 break;
1979 }
1980 }
1981
1982
1983 free(m_inp_mem_ptr);
1984 m_inp_mem_ptr = NULL;
1985 }
1986
1987 // Reset counters in mesg queues
1988 m_ftb_q.m_size=0;
1989 m_cmd_q.m_size=0;
1990 m_etb_q.m_size=0;
1991 m_ftb_q.m_read = m_ftb_q.m_write =0;
1992 m_cmd_q.m_read = m_cmd_q.m_write =0;
1993 m_etb_q.m_read = m_etb_q.m_write =0;
1994
1995 #ifdef _ANDROID_
1996 // Clear the strong reference
1997 DEBUG_PRINT_HIGH("Calling m_heap_ptr.clear()");
1998 m_heap_ptr.clear();
1999 #endif // _ANDROID_
2000 DEBUG_PRINT_HIGH("Calling venc_close()");
2001 if (handle) {
2002 handle->venc_close();
2003 DEBUG_PRINT_HIGH("Deleting HANDLE[%p]", handle);
2004 delete (handle);
2005 handle = NULL;
2006 }
2007 DEBUG_PRINT_INFO("Component Deinit");
2008 return OMX_ErrorNone;
2009 }
2010
2011
dev_stop(void)2012 OMX_U32 omx_venc::dev_stop( void)
2013 {
2014 return handle->venc_stop();
2015 }
2016
2017
dev_pause(void)2018 OMX_U32 omx_venc::dev_pause(void)
2019 {
2020 return handle->venc_pause();
2021 }
2022
dev_start(void)2023 OMX_U32 omx_venc::dev_start(void)
2024 {
2025 return handle->venc_start();
2026 }
2027
dev_flush(unsigned port)2028 OMX_U32 omx_venc::dev_flush(unsigned port)
2029 {
2030 return handle->venc_flush(port);
2031 }
dev_resume(void)2032 OMX_U32 omx_venc::dev_resume(void)
2033 {
2034 return handle->venc_resume();
2035 }
2036
dev_start_done(void)2037 OMX_U32 omx_venc::dev_start_done(void)
2038 {
2039 return handle->venc_start_done();
2040 }
2041
dev_set_message_thread_id(pthread_t tid)2042 OMX_U32 omx_venc::dev_set_message_thread_id(pthread_t tid)
2043 {
2044 return handle->venc_set_message_thread_id(tid);
2045 }
2046
dev_use_buf(void * buf_addr,unsigned port,unsigned index)2047 bool omx_venc::dev_use_buf(void *buf_addr,unsigned port,unsigned index)
2048 {
2049 return handle->venc_use_buf(buf_addr,port,index);
2050 }
2051
dev_free_buf(void * buf_addr,unsigned port)2052 bool omx_venc::dev_free_buf(void *buf_addr,unsigned port)
2053 {
2054 return handle->venc_free_buf(buf_addr,port);
2055 }
2056
dev_empty_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2057 bool omx_venc::dev_empty_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2058 {
2059 bool bret = false;
2060 bret = handle->venc_empty_buf(buffer, pmem_data_buf,index,fd);
2061 hw_overload = handle->hw_overload;
2062 return bret;
2063 }
2064
dev_fill_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2065 bool omx_venc::dev_fill_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2066 {
2067 return handle->venc_fill_buf(buffer, pmem_data_buf,index,fd);
2068 }
2069
dev_get_seq_hdr(void * buffer,unsigned size,unsigned * hdrlen)2070 bool omx_venc::dev_get_seq_hdr(void *buffer, unsigned size, unsigned *hdrlen)
2071 {
2072 return handle->venc_get_seq_hdr(buffer, size, hdrlen);
2073 }
2074
dev_get_capability_ltrcount(OMX_U32 * min,OMX_U32 * max,OMX_U32 * step_size)2075 bool omx_venc::dev_get_capability_ltrcount(OMX_U32 *min, OMX_U32 *max, OMX_U32 *step_size)
2076 {
2077 #ifdef _MSM8974_
2078 (void) min;
2079 (void) max;
2080 (void) step_size;
2081 DEBUG_PRINT_ERROR("Get Capability LTR Count is not supported");
2082 return false;
2083 #else
2084 return handle->venc_get_capability_ltrcount(min, max, step_size);
2085 #endif
2086 }
2087
dev_get_performance_level(OMX_U32 * perflevel)2088 bool omx_venc::dev_get_performance_level(OMX_U32 *perflevel)
2089 {
2090 #ifdef _MSM8974_
2091 return handle->venc_get_performance_level(perflevel);
2092 #else
2093 DEBUG_PRINT_ERROR("Get performance level is not supported");
2094 return false;
2095 #endif
2096 }
2097
dev_get_vui_timing_info(OMX_U32 * enabled)2098 bool omx_venc::dev_get_vui_timing_info(OMX_U32 *enabled)
2099 {
2100 #ifdef _MSM8974_
2101 return handle->venc_get_vui_timing_info(enabled);
2102 #else
2103 DEBUG_PRINT_ERROR("Get vui timing information is not supported");
2104 return false;
2105 #endif
2106 }
2107
dev_get_peak_bitrate(OMX_U32 * peakbitrate)2108 bool omx_venc::dev_get_peak_bitrate(OMX_U32 *peakbitrate)
2109 {
2110 #ifdef _MSM8974_
2111 return handle->venc_get_peak_bitrate(peakbitrate);
2112 #else
2113 DEBUG_PRINT_ERROR("Get peak bitrate is not supported");
2114 return false;
2115 #endif
2116 }
2117
dev_get_temporal_layer_caps(OMX_U32 * nMaxLayers,OMX_U32 * nMaxBLayers)2118 bool omx_venc::dev_get_temporal_layer_caps(OMX_U32 *nMaxLayers,
2119 OMX_U32 *nMaxBLayers) {
2120 return handle->venc_get_temporal_layer_caps(nMaxLayers, nMaxBLayers);
2121 }
2122
dev_loaded_start()2123 bool omx_venc::dev_loaded_start()
2124 {
2125 return handle->venc_loaded_start();
2126 }
2127
dev_loaded_stop()2128 bool omx_venc::dev_loaded_stop()
2129 {
2130 return handle->venc_loaded_stop();
2131 }
2132
dev_loaded_start_done()2133 bool omx_venc::dev_loaded_start_done()
2134 {
2135 return handle->venc_loaded_start_done();
2136 }
2137
dev_loaded_stop_done()2138 bool omx_venc::dev_loaded_stop_done()
2139 {
2140 return handle->venc_loaded_stop_done();
2141 }
2142
dev_get_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2143 bool omx_venc::dev_get_buf_req(OMX_U32 *min_buff_count,
2144 OMX_U32 *actual_buff_count,
2145 OMX_U32 *buff_size,
2146 OMX_U32 port)
2147 {
2148 return handle->venc_get_buf_req(min_buff_count,
2149 actual_buff_count,
2150 buff_size,
2151 port);
2152
2153 }
2154
dev_set_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2155 bool omx_venc::dev_set_buf_req(OMX_U32 *min_buff_count,
2156 OMX_U32 *actual_buff_count,
2157 OMX_U32 *buff_size,
2158 OMX_U32 port)
2159 {
2160 return handle->venc_set_buf_req(min_buff_count,
2161 actual_buff_count,
2162 buff_size,
2163 port);
2164
2165 }
2166
dev_is_video_session_supported(OMX_U32 width,OMX_U32 height)2167 bool omx_venc::dev_is_video_session_supported(OMX_U32 width, OMX_U32 height)
2168 {
2169 #ifdef _MSM8974_
2170 return handle->venc_is_video_session_supported(width,height);
2171 #else
2172 DEBUG_PRINT_LOW("Check against video capability not supported");
2173 return true;
2174 #endif
2175 }
2176
2177 #ifdef _MSM8974_
dev_handle_extradata(void * buffer,int index)2178 int omx_venc::dev_handle_extradata(void *buffer, int index)
2179 {
2180 return handle->handle_extradata(buffer, index);
2181 }
2182
dev_set_format(int color)2183 int omx_venc::dev_set_format(int color)
2184 {
2185 return handle->venc_set_format(color);
2186 }
2187 #endif
2188
async_message_process(void * context,void * message)2189 int omx_venc::async_message_process (void *context, void* message)
2190 {
2191 omx_video* omx = NULL;
2192 struct venc_msg *m_sVenc_msg = NULL;
2193 OMX_BUFFERHEADERTYPE* omxhdr = NULL;
2194 struct venc_buffer *temp_buff = NULL;
2195
2196 if (context == NULL || message == NULL) {
2197 DEBUG_PRINT_ERROR("ERROR: omx_venc::async_message_process invalid i/p params");
2198 return -1;
2199 }
2200 m_sVenc_msg = (struct venc_msg *)message;
2201
2202 omx = reinterpret_cast<omx_video*>(context);
2203
2204 if (m_sVenc_msg->statuscode != VEN_S_SUCCESS) {
2205 DEBUG_PRINT_ERROR("ERROR: async_msg_process() - Error statuscode = %lu",
2206 m_sVenc_msg->statuscode);
2207 if(m_sVenc_msg->msgcode == VEN_MSG_HW_OVERLOAD) {
2208 omx->omx_report_hw_overload();
2209 } else
2210 omx->omx_report_error();
2211 }
2212
2213 DEBUG_PRINT_LOW("omx_venc::async_message_process- msgcode = %lu",
2214 m_sVenc_msg->msgcode);
2215 switch (m_sVenc_msg->msgcode) {
2216 case VEN_MSG_START:
2217 omx->post_event (0,m_sVenc_msg->statuscode,\
2218 OMX_COMPONENT_GENERATE_START_DONE);
2219 break;
2220 case VEN_MSG_STOP:
2221 omx->post_event (0,m_sVenc_msg->statuscode,\
2222 OMX_COMPONENT_GENERATE_STOP_DONE);
2223 break;
2224 case VEN_MSG_RESUME:
2225 omx->post_event (0,m_sVenc_msg->statuscode,\
2226 OMX_COMPONENT_GENERATE_RESUME_DONE);
2227 break;
2228 case VEN_MSG_PAUSE:
2229 omx->post_event (0,m_sVenc_msg->statuscode,\
2230 OMX_COMPONENT_GENERATE_PAUSE_DONE);
2231 break;
2232 case VEN_MSG_FLUSH_INPUT_DONE:
2233
2234 omx->post_event (0,m_sVenc_msg->statuscode,\
2235 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH);
2236 break;
2237 case VEN_MSG_FLUSH_OUPUT_DONE:
2238 omx->post_event (0,m_sVenc_msg->statuscode,\
2239 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH);
2240 break;
2241 case VEN_MSG_INPUT_BUFFER_DONE:
2242 omxhdr = (OMX_BUFFERHEADERTYPE* )\
2243 m_sVenc_msg->buf.clientdata;
2244
2245 if (omxhdr == NULL ||
2246 (((OMX_U32)(omxhdr - omx->m_inp_mem_ptr) > omx->m_sInPortDef.nBufferCountActual) &&
2247 ((OMX_U32)(omxhdr - omx->meta_buffer_hdr) > omx->m_sInPortDef.nBufferCountActual))) {
2248 omxhdr = NULL;
2249 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2250 }
2251
2252 #ifdef _ANDROID_ICS_
2253 omx->omx_release_meta_buffer(omxhdr);
2254 #endif
2255 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2256 OMX_COMPONENT_GENERATE_EBD);
2257 break;
2258 case VEN_MSG_OUTPUT_BUFFER_DONE:
2259 {
2260 omxhdr = (OMX_BUFFERHEADERTYPE*)m_sVenc_msg->buf.clientdata;
2261 OMX_U32 bufIndex = (OMX_U32)(omxhdr - omx->m_out_mem_ptr);
2262
2263 if ( (omxhdr != NULL) &&
2264 (bufIndex < omx->m_sOutPortDef.nBufferCountActual)) {
2265 auto_lock l(omx->m_buf_lock);
2266 if (BITMASK_ABSENT(&(omx->m_out_bm_count), bufIndex)) {
2267 DEBUG_PRINT_ERROR("Recieved FBD for buffer that is already freed !");
2268 break;
2269 }
2270 if (!omx->is_secure_session() && (m_sVenc_msg->buf.len <= omxhdr->nAllocLen)) {
2271 omxhdr->nFilledLen = m_sVenc_msg->buf.len;
2272 omxhdr->nOffset = m_sVenc_msg->buf.offset;
2273 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2274 DEBUG_PRINT_LOW("o/p TS = %u", (unsigned int)m_sVenc_msg->buf.timestamp);
2275 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2276
2277 /*Use buffer case*/
2278 if (omx->output_use_buffer && !omx->m_use_output_pmem && !omx->is_secure_session()) {
2279 DEBUG_PRINT_LOW("memcpy() for o/p Heap UseBuffer");
2280 memcpy(omxhdr->pBuffer,
2281 (m_sVenc_msg->buf.ptrbuffer),
2282 m_sVenc_msg->buf.len);
2283 }
2284 } else {
2285 omxhdr->nFilledLen = 0;
2286 }
2287
2288 } else {
2289 omxhdr = NULL;
2290 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2291 }
2292 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2293 OMX_COMPONENT_GENERATE_FBD);
2294 break;
2295 }
2296 case VEN_MSG_NEED_OUTPUT_BUFFER:
2297 //TBD what action needs to be done here??
2298 break;
2299 #ifndef _MSM8974_
2300 case VEN_MSG_LTRUSE_FAILED:
2301 DEBUG_PRINT_ERROR("LTRUSE Failed!");
2302 omx->post_event (NULL,m_sVenc_msg->statuscode,
2303 OMX_COMPONENT_GENERATE_LTRUSE_FAILED);
2304 break;
2305 #endif
2306 default:
2307 DEBUG_PRINT_HIGH("Unknown msg received : %lu", m_sVenc_msg->msgcode);
2308 break;
2309 }
2310 return 0;
2311 }
2312
dev_color_align(OMX_BUFFERHEADERTYPE * buffer,OMX_U32 width,OMX_U32 height)2313 bool omx_venc::dev_color_align(OMX_BUFFERHEADERTYPE *buffer,
2314 OMX_U32 width, OMX_U32 height)
2315 {
2316 if(secure_session) {
2317 DEBUG_PRINT_ERROR("Cannot align colors in secure session.");
2318 return OMX_FALSE;
2319 }
2320 return handle->venc_color_align(buffer, width,height);
2321 }
2322
is_secure_session()2323 bool omx_venc::is_secure_session()
2324 {
2325 return secure_session;
2326 }
2327
dev_get_output_log_flag()2328 bool omx_venc::dev_get_output_log_flag()
2329 {
2330 return handle->venc_get_output_log_flag();
2331 }
2332
dev_output_log_buffers(const char * buffer,int bufferlen)2333 int omx_venc::dev_output_log_buffers(const char *buffer, int bufferlen)
2334 {
2335 return handle->venc_output_log_buffers(buffer, bufferlen);
2336 }
2337
dev_extradata_log_buffers(char * buffer)2338 int omx_venc::dev_extradata_log_buffers(char *buffer)
2339 {
2340 return handle->venc_extradata_log_buffers(buffer);
2341 }
2342