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 #include <fcntl.h>
32 #include <dlfcn.h>
33 #ifdef _ANDROID_ICS_
34 #include <media/hardware/HardwareAPI.h>
35 #endif
36 #ifdef _ANDROID_
37 #include <cutils/properties.h>
38 #endif
39 #ifdef _USE_GLIB_
40 #include <glib.h>
41 #define strlcpy g_strlcpy
42 #endif
43
44 extern int m_pipe;
45 static int bframes;
46 static int entropy;
47 static int perfmode;
48 static int lowlatency;
49 // factory function executed by the core to create instances
get_omx_component_factory_fn(void)50 void *get_omx_component_factory_fn(void)
51 {
52 return(new omx_venc);
53 }
54
perf_control()55 omx_venc::perf_control::perf_control()
56 {
57 m_perf_lib = NULL;
58 m_perf_lock_acquire = NULL;
59 m_perf_lock_release = NULL;
60 m_perf_handle = 0;
61 }
62
~perf_control()63 omx_venc::perf_control::~perf_control()
64 {
65 if (m_perf_handle != 0 && m_perf_lock_release) {
66 m_perf_lock_release(m_perf_handle);
67 }
68 if (m_perf_lib) {
69 dlclose(m_perf_lib);
70 }
71 }
72
send_hint_to_mpctl(bool state)73 void omx_venc::perf_control::send_hint_to_mpctl(bool state)
74 {
75 if (load_lib() == false) {
76 return;
77 }
78 /* 0x4601 maps to video encode callback in
79 * perflock, 46 is the enum number, 01 is
80 * the state being sent when perflock
81 * acquire succeeds
82 */
83 int arg = 0x4601;
84
85 if (m_perf_lock_acquire && state == true) {
86 m_perf_handle = m_perf_lock_acquire(0, 0, &arg, sizeof(arg) / sizeof(int));
87 DEBUG_PRINT_INFO("Video encode perflock acquired,handle=%d",m_perf_handle);
88 } else if (m_perf_lock_release && state == false) {
89 m_perf_lock_release(m_perf_handle);
90 DEBUG_PRINT_INFO("Video encode perflock released");
91 }
92 }
93
load_lib()94 bool omx_venc::perf_control::load_lib()
95 {
96 char perf_lib_path[PROPERTY_VALUE_MAX] = {0};
97 if (m_perf_lib)
98 return true;
99
100 if ((property_get("ro.vendor.extension_library", perf_lib_path, NULL) <= 0)) {
101 DEBUG_PRINT_ERROR("vendor library not set in ro.vendor.extension_library");
102 goto handle_err;
103 }
104 if ((m_perf_lib = dlopen(perf_lib_path, RTLD_NOW)) == NULL) {
105 DEBUG_PRINT_ERROR("Failed to open %s : %s",perf_lib_path, dlerror());
106 goto handle_err;
107 } else {
108 m_perf_lock_acquire = (perf_lock_acquire_t)dlsym(m_perf_lib, "perf_lock_acq");
109 if (m_perf_lock_acquire == NULL) {
110 DEBUG_PRINT_ERROR("Failed to load symbol: perf_lock_acq");
111 goto handle_err;
112 }
113 m_perf_lock_release = (perf_lock_release_t)dlsym(m_perf_lib, "perf_lock_rel");
114 if (m_perf_lock_release == NULL) {
115 DEBUG_PRINT_ERROR("Failed to load symbol: perf_lock_rel");
116 goto handle_err;
117 }
118 }
119 return true;
120
121 handle_err:
122 if(m_perf_lib != NULL) {
123 dlclose(m_perf_lib);
124 }
125 return false;
126 }
127
128 //constructor
129
omx_venc()130 omx_venc::omx_venc()
131 {
132 #ifdef _ANDROID_ICS_
133 meta_mode_enable = false;
134 memset(meta_buffer_hdr,0,sizeof(meta_buffer_hdr));
135 memset(meta_buffers,0,sizeof(meta_buffers));
136 memset(opaque_buffer_hdr,0,sizeof(opaque_buffer_hdr));
137 mUseProxyColorFormat = false;
138 get_syntaxhdr_enable = false;
139 #endif
140 bframes = entropy = 0;
141 char property_value[PROPERTY_VALUE_MAX] = {0};
142 property_get("vendor.vidc.debug.level", property_value, "1");
143 debug_level = strtoul(property_value, NULL, 16);
144 property_value[0] = '\0';
145 property_get("vendor.vidc.debug.bframes", property_value, "0");
146 bframes = atoi(property_value);
147 property_value[0] = '\0';
148 property_get("vendor.vidc.debug.entropy", property_value, "1");
149 entropy = !!atoi(property_value);
150 property_value[0] = '\0';
151 property_get("vendor.vidc.debug.perf.mode", property_value, "0");
152 perfmode = atoi(property_value);
153 property_value[0] = '\0';
154 handle = NULL;
155 property_get("vendor.vidc.debug.lowlatency", property_value, "0");
156 lowlatency = atoi(property_value);
157 property_value[0] = '\0';
158 m_perf_control.send_hint_to_mpctl(true);
159 }
160
~omx_venc()161 omx_venc::~omx_venc()
162 {
163 get_syntaxhdr_enable = false;
164 m_perf_control.send_hint_to_mpctl(false);
165 //nothing to do
166 }
167
168 /* ======================================================================
169 FUNCTION
170 omx_venc::ComponentInit
171
172 DESCRIPTION
173 Initialize the component.
174
175 PARAMETERS
176 ctxt -- Context information related to the self.
177 id -- Event identifier. This could be any of the following:
178 1. Command completion event
179 2. Buffer done callback event
180 3. Frame done callback event
181
182 RETURN VALUE
183 None.
184
185 ========================================================================== */
component_init(OMX_STRING role)186 OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
187 {
188
189 OMX_ERRORTYPE eRet = OMX_ErrorNone;
190
191 int fds[2];
192 int r;
193
194 OMX_VIDEO_CODINGTYPE codec_type;
195
196 DEBUG_PRINT_HIGH("omx_venc(): Inside component_init()");
197 // Copy the role information which provides the decoder m_nkind
198 strlcpy((char *)m_nkind,role,OMX_MAX_STRINGNAME_SIZE);
199 secure_session = false;
200
201 if (!strncmp((char *)m_nkind,"OMX.qcom.video.encoder.mpeg4",\
202 OMX_MAX_STRINGNAME_SIZE)) {
203 strlcpy((char *)m_cRole, "video_encoder.mpeg4",\
204 OMX_MAX_STRINGNAME_SIZE);
205 codec_type = OMX_VIDEO_CodingMPEG4;
206 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\
207 OMX_MAX_STRINGNAME_SIZE)) {
208 strlcpy((char *)m_cRole, "video_encoder.h263",OMX_MAX_STRINGNAME_SIZE);
209 codec_type = OMX_VIDEO_CodingH263;
210 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
211 OMX_MAX_STRINGNAME_SIZE)) {
212 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
213 codec_type = OMX_VIDEO_CodingAVC;
214 } else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
215 OMX_MAX_STRINGNAME_SIZE)) {
216 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
217 codec_type = OMX_VIDEO_CodingAVC;
218 secure_session = true;
219 }
220 #ifdef _MSM8974_
221 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.vp8", \
222 OMX_MAX_STRINGNAME_SIZE)) {
223 strlcpy((char *)m_cRole, "video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE);
224 codec_type = OMX_VIDEO_CodingVP8;
225 }
226 #endif
227 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc", \
228 OMX_MAX_STRINGNAME_SIZE)) {
229 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
230 codec_type = OMX_VIDEO_CodingHEVC;
231 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc.secure", \
232 OMX_MAX_STRINGNAME_SIZE)) {
233 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
234 codec_type = OMX_VIDEO_CodingHEVC;
235 secure_session = true;
236 } else {
237 DEBUG_PRINT_ERROR("ERROR: Unknown Component");
238 eRet = OMX_ErrorInvalidComponentName;
239 }
240
241 if (eRet != OMX_ErrorNone) {
242 return eRet;
243 }
244 #ifdef ENABLE_GET_SYNTAX_HDR
245 get_syntaxhdr_enable = true;
246 DEBUG_PRINT_HIGH("Get syntax header enabled");
247 #endif
248
249 handle = new venc_dev(this);
250
251 if (handle == NULL) {
252 DEBUG_PRINT_ERROR("ERROR: handle is NULL");
253 return OMX_ErrorInsufficientResources;
254 }
255
256 if (handle->venc_open(codec_type) != true) {
257 DEBUG_PRINT_ERROR("ERROR: venc_open failed");
258 eRet = OMX_ErrorInsufficientResources;
259 goto init_error;
260 }
261
262 //Intialise the OMX layer variables
263 memset(&m_pCallbacks,0,sizeof(OMX_CALLBACKTYPE));
264
265 OMX_INIT_STRUCT(&m_sPortParam, OMX_PORT_PARAM_TYPE);
266 m_sPortParam.nPorts = 0x2;
267 m_sPortParam.nStartPortNumber = (OMX_U32) PORT_INDEX_IN;
268
269 OMX_INIT_STRUCT(&m_sPortParam_audio, OMX_PORT_PARAM_TYPE);
270 m_sPortParam_audio.nPorts = 0;
271 m_sPortParam_audio.nStartPortNumber = 0;
272
273 OMX_INIT_STRUCT(&m_sPortParam_img, OMX_PORT_PARAM_TYPE);
274 m_sPortParam_img.nPorts = 0;
275 m_sPortParam_img.nStartPortNumber = 0;
276
277 OMX_INIT_STRUCT(&m_sParamBitrate, OMX_VIDEO_PARAM_BITRATETYPE);
278 m_sParamBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
279 m_sParamBitrate.eControlRate = OMX_Video_ControlRateVariableSkipFrames;
280 m_sParamBitrate.nTargetBitrate = 64000;
281
282 OMX_INIT_STRUCT(&m_sConfigBitrate, OMX_VIDEO_CONFIG_BITRATETYPE);
283 m_sConfigBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
284 m_sConfigBitrate.nEncodeBitrate = 64000;
285
286 OMX_INIT_STRUCT(&m_sConfigFramerate, OMX_CONFIG_FRAMERATETYPE);
287 m_sConfigFramerate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
288 m_sConfigFramerate.xEncodeFramerate = 30 << 16;
289
290 OMX_INIT_STRUCT(&m_sConfigIntraRefreshVOP, OMX_CONFIG_INTRAREFRESHVOPTYPE);
291 m_sConfigIntraRefreshVOP.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
292 m_sConfigIntraRefreshVOP.IntraRefreshVOP = OMX_FALSE;
293
294 OMX_INIT_STRUCT(&m_sConfigFrameRotation, OMX_CONFIG_ROTATIONTYPE);
295 m_sConfigFrameRotation.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
296 m_sConfigFrameRotation.nRotation = 0;
297
298 OMX_INIT_STRUCT(&m_sConfigAVCIDRPeriod, OMX_VIDEO_CONFIG_AVCINTRAPERIOD);
299 m_sConfigAVCIDRPeriod.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
300
301 OMX_INIT_STRUCT(&m_sPrependSPSPPS, PrependSPSPPSToIDRFramesParams);
302 m_sPrependSPSPPS.bEnable = OMX_FALSE;
303
304 OMX_INIT_STRUCT(&m_sSessionQuantization, OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
305 m_sSessionQuantization.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
306 m_sSessionQuantization.nQpI = 9;
307 m_sSessionQuantization.nQpP = 6;
308 m_sSessionQuantization.nQpB = 2;
309
310 OMX_INIT_STRUCT(&m_sSessionQPRange, OMX_QCOM_VIDEO_PARAM_QPRANGETYPE);
311 OMX_INIT_STRUCT(&m_sSessionIPBQPRange, OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE);
312 m_sSessionQPRange.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
313 m_sSessionIPBQPRange.nPortIndex = (OMX_U32)PORT_INDEX_OUT;
314 m_sSessionQPRange.minQP = 2;
315 if (codec_type == OMX_VIDEO_CodingAVC) {
316 m_sSessionQPRange.maxQP = 51;
317 } else {
318 m_sSessionQPRange.maxQP = 31;
319 }
320 m_sSessionIPBQPRange.minIQP =
321 m_sSessionIPBQPRange.minPQP =
322 m_sSessionIPBQPRange.minBQP = m_sSessionQPRange.minQP;
323 m_sSessionIPBQPRange.maxIQP =
324 m_sSessionIPBQPRange.maxPQP =
325 m_sSessionIPBQPRange.maxBQP = m_sSessionQPRange.maxQP;
326 OMX_INIT_STRUCT(&m_sAVCSliceFMO, OMX_VIDEO_PARAM_AVCSLICEFMO);
327 m_sAVCSliceFMO.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
328 m_sAVCSliceFMO.eSliceMode = OMX_VIDEO_SLICEMODE_AVCDefault;
329 m_sAVCSliceFMO.nNumSliceGroups = 0;
330 m_sAVCSliceFMO.nSliceGroupMapType = 0;
331 OMX_INIT_STRUCT(&m_sParamProfileLevel, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
332 m_sParamProfileLevel.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
333
334 OMX_INIT_STRUCT(&m_sIntraperiod, QOMX_VIDEO_INTRAPERIODTYPE);
335 m_sIntraperiod.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
336 m_sIntraperiod.nPFrames = (m_sConfigFramerate.xEncodeFramerate * 2) - 1;
337
338 OMX_INIT_STRUCT(&m_sErrorCorrection, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
339 m_sErrorCorrection.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
340 m_sErrorCorrection.bEnableDataPartitioning = OMX_FALSE;
341 m_sErrorCorrection.bEnableHEC = OMX_FALSE;
342 m_sErrorCorrection.bEnableResync = OMX_FALSE;
343 m_sErrorCorrection.bEnableRVLC = OMX_FALSE;
344 m_sErrorCorrection.nResynchMarkerSpacing = 0;
345
346 OMX_INIT_STRUCT(&m_sIntraRefresh, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
347 m_sIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
348 m_sIntraRefresh.eRefreshMode = OMX_VIDEO_IntraRefreshMax;
349
350 #ifdef SUPPORT_CONFIG_INTRA_REFRESH
351 OMX_INIT_STRUCT(&m_sConfigIntraRefresh, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE);
352 m_sConfigIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
353 m_sConfigIntraRefresh.nRefreshPeriod = 0;
354 #endif
355
356 OMX_INIT_STRUCT(&m_sConfigColorAspects, DescribeColorAspectsParams);
357 m_sConfigColorAspects.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
358 m_sConfigColorAspects.sAspects.mRange = ColorAspects::RangeUnspecified;
359 m_sConfigColorAspects.sAspects.mPrimaries = ColorAspects::PrimariesUnspecified;
360 m_sConfigColorAspects.sAspects.mMatrixCoeffs = ColorAspects::MatrixUnspecified;
361 m_sConfigColorAspects.sAspects.mTransfer = ColorAspects::TransferUnspecified;
362
363 if (codec_type == OMX_VIDEO_CodingMPEG4) {
364 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_MPEG4ProfileSimple;
365 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_MPEG4Level0;
366 } else if (codec_type == OMX_VIDEO_CodingH263) {
367 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_H263ProfileBaseline;
368 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_H263Level10;
369 } else if (codec_type == OMX_VIDEO_CodingAVC) {
370 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_AVCProfileBaseline;
371 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_AVCLevel1;
372 } else if (codec_type == OMX_VIDEO_CodingVP8) {
373 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_VP8ProfileMain;
374 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_VP8Level_Version0;
375 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
376 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_HEVCProfileMain;
377 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_HEVCMainTierLevel1;
378 }
379
380 OMX_INIT_STRUCT(&m_sParamEntropy, QOMX_VIDEO_H264ENTROPYCODINGTYPE);
381 m_sParamEntropy.bCabac = OMX_FALSE;
382
383 // Initialize the video parameters for input port
384 OMX_INIT_STRUCT(&m_sInPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
385 m_sInPortDef.nPortIndex= (OMX_U32) PORT_INDEX_IN;
386 m_sInPortDef.bEnabled = OMX_TRUE;
387 m_sInPortDef.bPopulated = OMX_FALSE;
388 m_sInPortDef.eDomain = OMX_PortDomainVideo;
389 m_sInPortDef.eDir = OMX_DirInput;
390 m_sInPortDef.format.video.cMIMEType = (char *)"YUV420";
391 m_sInPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH;
392 m_sInPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT;
393 m_sInPortDef.format.video.nStride = OMX_CORE_QCIF_WIDTH;
394 m_sInPortDef.format.video.nSliceHeight = OMX_CORE_QCIF_HEIGHT;
395 m_sInPortDef.format.video.nBitrate = 64000;
396 m_sInPortDef.format.video.xFramerate = 15 << 16;
397 m_sInPortDef.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)
398 QOMX_DEFAULT_COLOR_FMT;
399 m_sInPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
400
401 if (dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
402 &m_sInPortDef.nBufferCountActual,
403 &m_sInPortDef.nBufferSize,
404 m_sInPortDef.nPortIndex) != true) {
405 eRet = OMX_ErrorUndefined;
406 goto init_error;
407 }
408
409 // Initialize the video parameters for output port
410 OMX_INIT_STRUCT(&m_sOutPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
411 m_sOutPortDef.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
412 m_sOutPortDef.bEnabled = OMX_TRUE;
413 m_sOutPortDef.bPopulated = OMX_FALSE;
414 m_sOutPortDef.eDomain = OMX_PortDomainVideo;
415 m_sOutPortDef.eDir = OMX_DirOutput;
416 m_sOutPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH;
417 m_sOutPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT;
418 m_sOutPortDef.format.video.nBitrate = 64000;
419 m_sOutPortDef.format.video.xFramerate = 15 << 16;
420 m_sOutPortDef.format.video.eColorFormat = OMX_COLOR_FormatUnused;
421 if (codec_type == OMX_VIDEO_CodingMPEG4) {
422 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
423 } else if (codec_type == OMX_VIDEO_CodingH263) {
424 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
425 } else if (codec_type == OMX_VIDEO_CodingAVC) {
426 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
427 } else if (codec_type == OMX_VIDEO_CodingVP8) {
428 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingVP8;
429 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
430 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
431 }
432
433 if (dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
434 &m_sOutPortDef.nBufferCountActual,
435 &m_sOutPortDef.nBufferSize,
436 m_sOutPortDef.nPortIndex) != true) {
437 eRet = OMX_ErrorUndefined;
438 goto init_error;
439 }
440
441 // Initialize the video color format for input port
442 OMX_INIT_STRUCT(&m_sInPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
443 m_sInPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_IN;
444 m_sInPortFormat.nIndex = 0;
445 m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE)
446 QOMX_DEFAULT_COLOR_FMT;
447 m_sInPortFormat.eCompressionFormat = OMX_VIDEO_CodingUnused;
448
449
450 // Initialize the compression format for output port
451 OMX_INIT_STRUCT(&m_sOutPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
452 m_sOutPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
453 m_sOutPortFormat.nIndex = 0;
454 m_sOutPortFormat.eColorFormat = OMX_COLOR_FormatUnused;
455 if (codec_type == OMX_VIDEO_CodingMPEG4) {
456 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
457 } else if (codec_type == OMX_VIDEO_CodingH263) {
458 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingH263;
459 } else if (codec_type == OMX_VIDEO_CodingAVC) {
460 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingAVC;
461 } else if (codec_type == OMX_VIDEO_CodingVP8) {
462 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingVP8;
463 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
464 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingHEVC;
465 }
466
467 // mandatory Indices for kronos test suite
468 OMX_INIT_STRUCT(&m_sPriorityMgmt, OMX_PRIORITYMGMTTYPE);
469
470 OMX_INIT_STRUCT(&m_sInBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
471 m_sInBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_IN;
472
473 OMX_INIT_STRUCT(&m_sOutBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
474 m_sOutBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
475
476 OMX_INIT_STRUCT(&m_sParamInitqp, QOMX_EXTNINDEX_VIDEO_INITIALQP);
477 m_sParamInitqp.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
478
479 // mp4 specific init
480 OMX_INIT_STRUCT(&m_sParamMPEG4, OMX_VIDEO_PARAM_MPEG4TYPE);
481 m_sParamMPEG4.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
482 m_sParamMPEG4.eProfile = OMX_VIDEO_MPEG4ProfileSimple;
483 m_sParamMPEG4.eLevel = OMX_VIDEO_MPEG4Level0;
484 m_sParamMPEG4.nSliceHeaderSpacing = 0;
485 m_sParamMPEG4.bSVH = OMX_FALSE;
486 m_sParamMPEG4.bGov = OMX_FALSE;
487 m_sParamMPEG4.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps
488 m_sParamMPEG4.bACPred = OMX_TRUE;
489 m_sParamMPEG4.nTimeIncRes = 30; // delta = 2 @ 15 fps
490 m_sParamMPEG4.nAllowedPictureTypes = 2; // pframe and iframe
491 m_sParamMPEG4.nHeaderExtension = 1; // number of video packet headers per vop
492 m_sParamMPEG4.bReversibleVLC = OMX_FALSE;
493
494 // h263 specific init
495 OMX_INIT_STRUCT(&m_sParamH263, OMX_VIDEO_PARAM_H263TYPE);
496 m_sParamH263.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
497 m_sParamH263.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps
498 m_sParamH263.nBFrames = 0;
499 m_sParamH263.eProfile = OMX_VIDEO_H263ProfileBaseline;
500 m_sParamH263.eLevel = OMX_VIDEO_H263Level10;
501 m_sParamH263.bPLUSPTYPEAllowed = OMX_FALSE;
502 m_sParamH263.nAllowedPictureTypes = 2;
503 m_sParamH263.bForceRoundingTypeToZero = OMX_TRUE;
504 m_sParamH263.nPictureHeaderRepetition = 0;
505 m_sParamH263.nGOBHeaderInterval = 1;
506
507 // h264 specific init
508 OMX_INIT_STRUCT(&m_sParamAVC, OMX_VIDEO_PARAM_AVCTYPE);
509 m_sParamAVC.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
510 m_sParamAVC.nSliceHeaderSpacing = 0;
511 m_sParamAVC.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps
512 m_sParamAVC.nBFrames = 0;
513 m_sParamAVC.bUseHadamard = OMX_FALSE;
514 m_sParamAVC.nRefIdx10ActiveMinus1 = 1;
515 m_sParamAVC.nRefIdx11ActiveMinus1 = 0;
516 m_sParamAVC.bEnableUEP = OMX_FALSE;
517 m_sParamAVC.bEnableFMO = OMX_FALSE;
518 m_sParamAVC.bEnableASO = OMX_FALSE;
519 m_sParamAVC.bEnableRS = OMX_FALSE;
520 m_sParamAVC.eProfile = OMX_VIDEO_AVCProfileBaseline;
521 m_sParamAVC.eLevel = OMX_VIDEO_AVCLevel1;
522 m_sParamAVC.nAllowedPictureTypes = 2;
523 m_sParamAVC.bFrameMBsOnly = OMX_FALSE;
524 m_sParamAVC.bMBAFF = OMX_FALSE;
525 m_sParamAVC.bEntropyCodingCABAC = OMX_FALSE;
526 m_sParamAVC.bWeightedPPrediction = OMX_FALSE;
527 m_sParamAVC.nWeightedBipredicitonMode = 0;
528 m_sParamAVC.bconstIpred = OMX_FALSE;
529 m_sParamAVC.bDirect8x8Inference = OMX_FALSE;
530 m_sParamAVC.bDirectSpatialTemporal = OMX_FALSE;
531 m_sParamAVC.nCabacInitIdc = 0;
532 m_sParamAVC.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
533
534 // VP8 specific init
535 OMX_INIT_STRUCT(&m_sParamVP8, OMX_VIDEO_PARAM_VP8TYPE);
536 m_sParamVP8.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
537 m_sParamVP8.eProfile = OMX_VIDEO_VP8ProfileMain;
538 m_sParamVP8.eLevel = OMX_VIDEO_VP8Level_Version0;
539 m_sParamVP8.nDCTPartitions = 0;
540 m_sParamVP8.bErrorResilientMode = OMX_FALSE;
541
542 // HEVC specific init
543 OMX_INIT_STRUCT(&m_sParamHEVC, OMX_VIDEO_PARAM_HEVCTYPE);
544 m_sParamHEVC.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
545 m_sParamHEVC.eProfile = OMX_VIDEO_HEVCProfileMain;
546 m_sParamHEVC.eLevel = OMX_VIDEO_HEVCMainTierLevel1;
547
548 OMX_INIT_STRUCT(&m_sParamLTRMode, QOMX_VIDEO_PARAM_LTRMODE_TYPE);
549 m_sParamLTRMode.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
550 m_sParamLTRMode.eLTRMode = QOMX_VIDEO_LTRMode_Disable;
551
552 OMX_INIT_STRUCT(&m_sParamLTRCount, QOMX_VIDEO_PARAM_LTRCOUNT_TYPE);
553 m_sParamLTRCount.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
554 m_sParamLTRCount.nCount = 0;
555
556 OMX_INIT_STRUCT(&m_sConfigDeinterlace, OMX_VIDEO_CONFIG_DEINTERLACE);
557 m_sConfigDeinterlace.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
558 m_sConfigDeinterlace.nEnable = OMX_FALSE;
559
560 OMX_INIT_STRUCT(&m_sHierLayers, QOMX_VIDEO_HIERARCHICALLAYERS);
561 m_sHierLayers.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
562 m_sHierLayers.nNumLayers = 0;
563 m_sHierLayers.eHierarchicalCodingType = QOMX_HIERARCHICALCODING_P;
564
565 OMX_INIT_STRUCT(&m_sMBIStatistics, OMX_QOMX_VIDEO_MBI_STATISTICS);
566 m_sMBIStatistics.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
567 m_sMBIStatistics.eMBIStatisticsType = QOMX_MBI_STATISTICS_MODE_DEFAULT;
568
569 OMX_INIT_STRUCT(&m_slowLatencyMode, QOMX_EXTNINDEX_VIDEO_VENC_LOW_LATENCY_MODE);
570 m_slowLatencyMode.bLowLatencyMode = OMX_FALSE;
571
572 OMX_INIT_STRUCT(&m_sParamTemporalLayers, OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE);
573 m_sParamTemporalLayers.eSupportedPatterns = OMX_VIDEO_AndroidTemporalLayeringPatternAndroid;
574
575 OMX_INIT_STRUCT(&m_sConfigTemporalLayers, OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE);
576
577 OMX_INIT_STRUCT(&m_sParamAVTimerTimestampMode, QOMX_ENABLETYPE);
578 m_sParamAVTimerTimestampMode.bEnable = OMX_FALSE;
579
580 m_state = OMX_StateLoaded;
581 m_sExtraData = 0;
582
583 if (eRet == OMX_ErrorNone) {
584 if (pipe(fds)) {
585 DEBUG_PRINT_ERROR("ERROR: pipe creation failed");
586 eRet = OMX_ErrorInsufficientResources;
587 goto init_error;
588 } else {
589 if (fds[0] == 0 || fds[1] == 0) {
590 if (pipe(fds)) {
591 DEBUG_PRINT_ERROR("ERROR: pipe creation failed");
592 eRet = OMX_ErrorInsufficientResources;
593 goto init_error;
594 }
595 }
596 if (eRet == OMX_ErrorNone) {
597 m_pipe_in = fds[0];
598 m_pipe_out = fds[1];
599
600 msg_thread_created = true;
601 r = pthread_create(&msg_thread_id,0, message_thread_enc, this);
602 if (r < 0) {
603 DEBUG_PRINT_ERROR("ERROR: message_thread_enc thread creation failed");
604 eRet = OMX_ErrorInsufficientResources;
605 msg_thread_created = false;
606 goto init_error;
607 } else {
608 async_thread_created = true;
609 r = pthread_create(&async_thread_id,0, venc_dev::async_venc_message_thread, this);
610 if (r < 0) {
611 DEBUG_PRINT_ERROR("ERROR: venc_dev::async_venc_message_thread thread creation failed");
612 eRet = OMX_ErrorInsufficientResources;
613 async_thread_created = false;
614
615 msg_thread_stop = true;
616 pthread_join(msg_thread_id,NULL);
617 msg_thread_created = false;
618
619 goto init_error;
620 } else
621 dev_set_message_thread_id(async_thread_id);
622 }
623 }
624 }
625 }
626
627 if (perfmode) {
628 QOMX_EXTNINDEX_VIDEO_PERFMODE pParam;
629 pParam.nPerfMode = perfmode;
630 DEBUG_PRINT_LOW("Perfmode = 0x%x", pParam.nPerfMode);
631 if (!handle->venc_set_config(&pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode))
632 DEBUG_PRINT_ERROR("Failed setting PerfMode to %d", pParam.nPerfMode);
633 }
634
635 if (lowlatency)
636 {
637 QOMX_ENABLETYPE low_latency;
638 low_latency.bEnable = OMX_TRUE;
639 DEBUG_PRINT_LOW("Enable lowlatency mode");
640 if (!handle->venc_set_param(&low_latency,
641 (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencLowLatencyMode)) {
642 DEBUG_PRINT_ERROR("Failed enabling low latency mode");
643 }
644 }
645 DEBUG_PRINT_INFO("Component_init : %s : return = 0x%x", m_nkind, eRet);
646
647 {
648 VendorExtensionStore *extStore = const_cast<VendorExtensionStore *>(&mVendorExtensionStore);
649 init_vendor_extensions(*extStore);
650 mVendorExtensionStore.dumpExtensions((const char *)m_nkind);
651 }
652
653 return eRet;
654 init_error:
655 handle->venc_close();
656 delete handle;
657 handle = NULL;
658 return eRet;
659 }
660
661
662 /* ======================================================================
663 FUNCTION
664 omx_venc::Setparameter
665
666 DESCRIPTION
667 OMX Set Parameter method implementation.
668
669 PARAMETERS
670 <TBD>.
671
672 RETURN VALUE
673 OMX Error None if successful.
674
675 ========================================================================== */
set_parameter(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_INDEXTYPE paramIndex,OMX_IN OMX_PTR paramData)676 OMX_ERRORTYPE omx_venc::set_parameter(OMX_IN OMX_HANDLETYPE hComp,
677 OMX_IN OMX_INDEXTYPE paramIndex,
678 OMX_IN OMX_PTR paramData)
679 {
680 (void)hComp;
681 OMX_ERRORTYPE eRet = OMX_ErrorNone;
682
683
684 if (m_state == OMX_StateInvalid) {
685 DEBUG_PRINT_ERROR("ERROR: Set Param in Invalid State");
686 return OMX_ErrorInvalidState;
687 }
688 if (paramData == NULL) {
689 DEBUG_PRINT_ERROR("ERROR: Get Param in Invalid paramData");
690 return OMX_ErrorBadParameter;
691 }
692
693 /*set_parameter can be called in loaded state
694 or disabled port */
695 if (m_state == OMX_StateLoaded
696 || m_sInPortDef.bEnabled == OMX_FALSE
697 || m_sOutPortDef.bEnabled == OMX_FALSE) {
698 DEBUG_PRINT_LOW("Set Parameter called in valid state");
699 } else {
700 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State");
701 return OMX_ErrorIncorrectStateOperation;
702 }
703
704 switch ((int)paramIndex) {
705 case OMX_IndexParamPortDefinition:
706 {
707 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_PORTDEFINITIONTYPE);
708 OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
709 portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
710 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPortDefinition H= %d, W = %d",
711 (int)portDefn->format.video.nFrameHeight,
712 (int)portDefn->format.video.nFrameWidth);
713
714 if (PORT_INDEX_IN == portDefn->nPortIndex) {
715 if (!dev_is_video_session_supported(portDefn->format.video.nFrameWidth,
716 portDefn->format.video.nFrameHeight)) {
717 DEBUG_PRINT_ERROR("video session not supported");
718 omx_report_unsupported_setting();
719 return OMX_ErrorUnsupportedSetting;
720 }
721 DEBUG_PRINT_LOW("i/p actual cnt requested = %u", (unsigned int)portDefn->nBufferCountActual);
722 DEBUG_PRINT_LOW("i/p min cnt requested = %u", (unsigned int)portDefn->nBufferCountMin);
723 DEBUG_PRINT_LOW("i/p buffersize requested = %u", (unsigned int)portDefn->nBufferSize);
724 if (portDefn->nBufferCountActual > MAX_NUM_INPUT_BUFFERS) {
725 DEBUG_PRINT_ERROR("ERROR: (In_PORT) actual count (%u) exceeds max(%u)",
726 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_INPUT_BUFFERS);
727 return OMX_ErrorUnsupportedSetting;
728 }
729 if (m_inp_mem_ptr &&
730 (portDefn->nBufferCountActual != m_sInPortDef.nBufferCountActual ||
731 portDefn->nBufferSize != m_sInPortDef.nBufferSize)) {
732 DEBUG_PRINT_ERROR("ERROR: (In_PORT) buffer count/size can change only if port is unallocated !");
733 return OMX_ErrorInvalidState;
734 }
735 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) {
736 DEBUG_PRINT_ERROR("ERROR: (In_PORT) Min buffers (%u) > actual count (%u)",
737 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual);
738 return OMX_ErrorUnsupportedSetting;
739 }
740 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) {
741 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed");
742 return handle->hw_overload ? OMX_ErrorInsufficientResources :
743 OMX_ErrorUnsupportedSetting;
744 }
745
746 DEBUG_PRINT_LOW("i/p previous actual cnt = %u", (unsigned int)m_sInPortDef.nBufferCountActual);
747 DEBUG_PRINT_LOW("i/p previous min cnt = %u", (unsigned int)m_sInPortDef.nBufferCountMin);
748 memcpy(&m_sInPortDef, portDefn,sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
749
750 #ifdef _ANDROID_ICS_
751 if (portDefn->format.video.eColorFormat ==
752 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) {
753 m_sInPortDef.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)
754 QOMX_DEFAULT_COLOR_FMT;
755 if (!mUseProxyColorFormat) {
756 if (!c2d_conv.init()) {
757 DEBUG_PRINT_ERROR("C2D init failed");
758 return OMX_ErrorUnsupportedSetting;
759 }
760 DEBUG_PRINT_HIGH("C2D init is successful");
761 }
762 mUseProxyColorFormat = true;
763 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ;
764 } else
765 mUseProxyColorFormat = false;
766 #endif
767 /*Query Input Buffer Requirements*/
768 dev_get_buf_req (&m_sInPortDef.nBufferCountMin,
769 &m_sInPortDef.nBufferCountActual,
770 &m_sInPortDef.nBufferSize,
771 m_sInPortDef.nPortIndex);
772
773 /*Query ouput Buffer Requirements*/
774 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin,
775 &m_sOutPortDef.nBufferCountActual,
776 &m_sOutPortDef.nBufferSize,
777 m_sOutPortDef.nPortIndex);
778 m_sInPortDef.nBufferCountActual = portDefn->nBufferCountActual;
779 } else if (PORT_INDEX_OUT == portDefn->nPortIndex) {
780 DEBUG_PRINT_LOW("o/p actual cnt requested = %u", (unsigned int)portDefn->nBufferCountActual);
781 DEBUG_PRINT_LOW("o/p min cnt requested = %u", (unsigned int)portDefn->nBufferCountMin);
782 DEBUG_PRINT_LOW("o/p buffersize requested = %u", (unsigned int)portDefn->nBufferSize);
783
784 if (portDefn->nBufferCountActual > MAX_NUM_OUTPUT_BUFFERS) {
785 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) actual count (%u) exceeds max(%u)",
786 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_OUTPUT_BUFFERS);
787 return OMX_ErrorUnsupportedSetting;
788 }
789 if (m_out_mem_ptr &&
790 (portDefn->nBufferCountActual != m_sOutPortDef.nBufferCountActual ||
791 portDefn->nBufferSize != m_sOutPortDef.nBufferSize)) {
792 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) buffer count/size can change only if port is unallocated !");
793 return OMX_ErrorInvalidState;
794 }
795
796 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) {
797 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) Min buffers (%u) > actual count (%u)",
798 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual);
799 return OMX_ErrorUnsupportedSetting;
800 }
801 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) {
802 DEBUG_PRINT_ERROR("ERROR: venc_set_param output failed");
803 return OMX_ErrorUnsupportedSetting;
804 }
805 memcpy(&m_sOutPortDef,portDefn,sizeof(struct OMX_PARAM_PORTDEFINITIONTYPE));
806 #ifdef _MSM8974_
807 /*Query ouput Buffer Requirements*/
808 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
809 &m_sOutPortDef.nBufferCountActual,
810 &m_sOutPortDef.nBufferSize,
811 m_sOutPortDef.nPortIndex);
812 #endif
813 update_profile_level(); //framerate , bitrate
814
815 DEBUG_PRINT_LOW("o/p previous actual cnt = %u", (unsigned int)m_sOutPortDef.nBufferCountActual);
816 DEBUG_PRINT_LOW("o/p previous min cnt = %u", (unsigned int)m_sOutPortDef.nBufferCountMin);
817 m_sOutPortDef.nBufferCountActual = portDefn->nBufferCountActual;
818 } else {
819 DEBUG_PRINT_ERROR("ERROR: Set_parameter: Bad Port idx %d",
820 (int)portDefn->nPortIndex);
821 eRet = OMX_ErrorBadPortIndex;
822 }
823 m_sConfigFramerate.xEncodeFramerate = portDefn->format.video.xFramerate;
824 m_sConfigBitrate.nEncodeBitrate = portDefn->format.video.nBitrate;
825 m_sParamBitrate.nTargetBitrate = portDefn->format.video.nBitrate;
826 }
827 break;
828
829 case OMX_IndexParamVideoPortFormat:
830 {
831 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PORTFORMATTYPE);
832 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt =
833 (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData;
834 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d",
835 portFmt->eColorFormat);
836 //set the driver with the corresponding values
837 if (PORT_INDEX_IN == portFmt->nPortIndex) {
838 if (handle->venc_set_param(paramData,OMX_IndexParamVideoPortFormat) != true) {
839 return OMX_ErrorUnsupportedSetting;
840 }
841
842 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d",
843 portFmt->eColorFormat);
844 update_profile_level(); //framerate
845
846 #ifdef _ANDROID_ICS_
847 if (portFmt->eColorFormat ==
848 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) {
849 m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE)
850 QOMX_DEFAULT_COLOR_FMT;
851 if (!mUseProxyColorFormat) {
852 if (!c2d_conv.init()) {
853 DEBUG_PRINT_ERROR("C2D init failed");
854 return OMX_ErrorUnsupportedSetting;
855 }
856 DEBUG_PRINT_HIGH("C2D init is successful");
857 }
858 mUseProxyColorFormat = true;
859 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ;
860 } else
861 #endif
862 {
863 m_sInPortFormat.eColorFormat = portFmt->eColorFormat;
864 m_sInPortDef.format.video.eColorFormat = portFmt->eColorFormat;
865 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB;
866 mUseProxyColorFormat = false;
867 }
868 m_sInPortFormat.xFramerate = portFmt->xFramerate;
869 }
870 //TODO if no use case for O/P port,delet m_sOutPortFormat
871 }
872 break;
873 case OMX_IndexParamVideoInit:
874 { //TODO, do we need this index set param
875 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PORT_PARAM_TYPE);
876 OMX_PORT_PARAM_TYPE* pParam = (OMX_PORT_PARAM_TYPE*)(paramData);
877 DEBUG_PRINT_LOW("Set OMX_IndexParamVideoInit called");
878 break;
879 }
880
881 case OMX_IndexParamVideoBitrate:
882 {
883 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_BITRATETYPE);
884 OMX_VIDEO_PARAM_BITRATETYPE* pParam = (OMX_VIDEO_PARAM_BITRATETYPE*)paramData;
885 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoBitrate");
886 if (handle->venc_set_param(paramData,OMX_IndexParamVideoBitrate) != true) {
887 return OMX_ErrorUnsupportedSetting;
888 }
889 m_sParamBitrate.nTargetBitrate = pParam->nTargetBitrate;
890 m_sParamBitrate.eControlRate = pParam->eControlRate;
891 update_profile_level(); //bitrate
892 m_sConfigBitrate.nEncodeBitrate = pParam->nTargetBitrate;
893 m_sInPortDef.format.video.nBitrate = pParam->nTargetBitrate;
894 m_sOutPortDef.format.video.nBitrate = pParam->nTargetBitrate;
895 /* RC mode chan chage buffer requirements on Input port */
896 dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
897 &m_sInPortDef.nBufferCountActual,
898 &m_sInPortDef.nBufferSize,
899 m_sInPortDef.nPortIndex);
900 DEBUG_PRINT_LOW("bitrate = %u", (unsigned int)m_sOutPortDef.format.video.nBitrate);
901 break;
902 }
903 case OMX_IndexParamVideoMpeg4:
904 {
905 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_MPEG4TYPE);
906 OMX_VIDEO_PARAM_MPEG4TYPE* pParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)paramData;
907 OMX_VIDEO_PARAM_MPEG4TYPE mp4_param;
908 memcpy(&mp4_param, pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE));
909 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoMpeg4");
910 if (pParam->eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) {
911 #ifdef _MSM8974_
912 if (pParam->nBFrames || bframes)
913 mp4_param.nBFrames = 1;
914 else
915 mp4_param.nBFrames = 0;
916 DEBUG_PRINT_HIGH("MPEG4: %u BFrames are being set", (unsigned int)mp4_param.nBFrames);
917 #endif
918 } else {
919 if (pParam->nBFrames) {
920 DEBUG_PRINT_ERROR("Warning: B frames not supported");
921 mp4_param.nBFrames = 0;
922 }
923 }
924 if (handle->venc_set_param(&mp4_param,OMX_IndexParamVideoMpeg4) != true) {
925 return OMX_ErrorUnsupportedSetting;
926 }
927 memcpy(&m_sParamMPEG4,pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE));
928 m_sIntraperiod.nPFrames = m_sParamMPEG4.nPFrames;
929 if (pParam->nBFrames || bframes)
930 m_sIntraperiod.nBFrames = m_sParamMPEG4.nBFrames = mp4_param.nBFrames;
931 else
932 m_sIntraperiod.nBFrames = m_sParamMPEG4.nBFrames;
933 break;
934 }
935 case OMX_IndexParamVideoH263:
936 {
937 OMX_VIDEO_PARAM_H263TYPE* pParam = (OMX_VIDEO_PARAM_H263TYPE*)paramData;
938 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoH263");
939 if (handle->venc_set_param(paramData,OMX_IndexParamVideoH263) != true) {
940 return OMX_ErrorUnsupportedSetting;
941 }
942 memcpy(&m_sParamH263,pParam, sizeof(struct OMX_VIDEO_PARAM_H263TYPE));
943 m_sIntraperiod.nPFrames = m_sParamH263.nPFrames;
944 m_sIntraperiod.nBFrames = m_sParamH263.nBFrames;
945 break;
946 }
947 case OMX_IndexParamVideoAvc:
948 {
949 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_AVCTYPE);
950 OMX_VIDEO_PARAM_AVCTYPE* pParam = (OMX_VIDEO_PARAM_AVCTYPE*)paramData;
951 OMX_VIDEO_PARAM_AVCTYPE avc_param;
952 memcpy(&avc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_AVCTYPE));
953 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAvc");
954
955 avc_param.nBFrames = 0;
956 if ((pParam->eProfile == OMX_VIDEO_AVCProfileHigh)||
957 (pParam->eProfile == OMX_VIDEO_AVCProfileMain)) {
958
959 if (pParam->nBFrames) {
960 avc_param.nBFrames = pParam->nBFrames;
961 DEBUG_PRINT_LOW("B frames set using Client setparam to %d",
962 avc_param.nBFrames);
963 }
964
965 if (bframes ) {
966 avc_param.nBFrames = bframes;
967 DEBUG_PRINT_LOW("B frames set using setprop to %d",
968 avc_param.nBFrames);
969 }
970
971 DEBUG_PRINT_HIGH("AVC: BFrames: %u", (unsigned int)avc_param.nBFrames);
972 avc_param.bEntropyCodingCABAC = (OMX_BOOL)(avc_param.bEntropyCodingCABAC && entropy);
973 avc_param.nCabacInitIdc = entropy ? avc_param.nCabacInitIdc : 0;
974 } else {
975 if (pParam->nBFrames) {
976 DEBUG_PRINT_ERROR("Warning: B frames not supported");
977 }
978 }
979
980 if (handle->venc_set_param(&avc_param,OMX_IndexParamVideoAvc) != true) {
981 return OMX_ErrorUnsupportedSetting;
982 }
983 memcpy(&m_sParamAVC,pParam, sizeof(struct OMX_VIDEO_PARAM_AVCTYPE));
984 m_sIntraperiod.nPFrames = m_sParamAVC.nPFrames;
985 if (pParam->nBFrames || bframes)
986 m_sIntraperiod.nBFrames = m_sParamAVC.nBFrames = avc_param.nBFrames;
987 else
988 m_sIntraperiod.nBFrames = m_sParamAVC.nBFrames;
989 break;
990 }
991 case (OMX_INDEXTYPE)OMX_IndexParamVideoVp8:
992 {
993 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_VP8TYPE);
994 OMX_VIDEO_PARAM_VP8TYPE* pParam = (OMX_VIDEO_PARAM_VP8TYPE*)paramData;
995 OMX_VIDEO_PARAM_VP8TYPE vp8_param;
996 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoVp8");
997 if (pParam->nDCTPartitions != m_sParamVP8.nDCTPartitions ||
998 pParam->bErrorResilientMode != m_sParamVP8.bErrorResilientMode) {
999 DEBUG_PRINT_ERROR("VP8 doesn't support nDCTPartitions or bErrorResilientMode");
1000 }
1001 memcpy(&vp8_param, pParam, sizeof( struct OMX_VIDEO_PARAM_VP8TYPE));
1002 if (handle->venc_set_param(&vp8_param, (OMX_INDEXTYPE)OMX_IndexParamVideoVp8) != true) {
1003 return OMX_ErrorUnsupportedSetting;
1004 }
1005 memcpy(&m_sParamVP8,pParam, sizeof(struct OMX_VIDEO_PARAM_VP8TYPE));
1006 break;
1007 }
1008 case (OMX_INDEXTYPE)OMX_IndexParamVideoHevc:
1009 {
1010 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_HEVCTYPE);
1011 OMX_VIDEO_PARAM_HEVCTYPE* pParam = (OMX_VIDEO_PARAM_HEVCTYPE*)paramData;
1012 OMX_VIDEO_PARAM_HEVCTYPE hevc_param;
1013 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoHevc");
1014 memcpy(&hevc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_HEVCTYPE));
1015 if (handle->venc_set_param(&hevc_param, (OMX_INDEXTYPE)OMX_IndexParamVideoHevc) != true) {
1016 DEBUG_PRINT_ERROR("Failed : set_parameter: OMX_IndexParamVideoHevc");
1017 return OMX_ErrorUnsupportedSetting;
1018 }
1019 memcpy(&m_sParamHEVC, pParam, sizeof(struct OMX_VIDEO_PARAM_HEVCTYPE));
1020 break;
1021 }
1022 case OMX_IndexParamVideoProfileLevelCurrent:
1023 {
1024 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
1025 OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData;
1026 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoProfileLevelCurrent");
1027 if (handle->venc_set_param(pParam,OMX_IndexParamVideoProfileLevelCurrent) != true) {
1028 DEBUG_PRINT_ERROR("set_parameter: OMX_IndexParamVideoProfileLevelCurrent failed for Profile: %u "
1029 "Level :%u", (unsigned int)pParam->eProfile, (unsigned int)pParam->eLevel);
1030 return OMX_ErrorUnsupportedSetting;
1031 }
1032 m_sParamProfileLevel.eProfile = pParam->eProfile;
1033 m_sParamProfileLevel.eLevel = pParam->eLevel;
1034
1035 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\
1036 OMX_MAX_STRINGNAME_SIZE)) {
1037 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)m_sParamProfileLevel.eProfile;
1038 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)m_sParamProfileLevel.eLevel;
1039 DEBUG_PRINT_LOW("MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile,
1040 m_sParamMPEG4.eLevel);
1041 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\
1042 OMX_MAX_STRINGNAME_SIZE)) {
1043 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)m_sParamProfileLevel.eProfile;
1044 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)m_sParamProfileLevel.eLevel;
1045 DEBUG_PRINT_LOW("H263 profile = %d, level = %d", m_sParamH263.eProfile,
1046 m_sParamH263.eLevel);
1047 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
1048 OMX_MAX_STRINGNAME_SIZE)) {
1049 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile;
1050 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel;
1051 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1052 m_sParamAVC.eLevel);
1053 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
1054 OMX_MAX_STRINGNAME_SIZE)) {
1055 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile;
1056 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel;
1057 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1058 m_sParamAVC.eLevel);
1059 }
1060 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",\
1061 OMX_MAX_STRINGNAME_SIZE)) {
1062 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)m_sParamProfileLevel.eProfile;
1063 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)m_sParamProfileLevel.eLevel;
1064 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile,
1065 m_sParamVP8.eLevel);
1066 }
1067 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",\
1068 OMX_MAX_STRINGNAME_SIZE)) {
1069 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)m_sParamProfileLevel.eProfile;
1070 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)m_sParamProfileLevel.eLevel;
1071 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile,
1072 m_sParamHEVC.eLevel);
1073 }
1074
1075 break;
1076 }
1077 case OMX_IndexParamStandardComponentRole:
1078 {
1079 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_COMPONENTROLETYPE);
1080 OMX_PARAM_COMPONENTROLETYPE *comp_role;
1081 comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData;
1082 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamStandardComponentRole %s",
1083 comp_role->cRole);
1084
1085 if ((m_state == OMX_StateLoaded)&&
1086 !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING)) {
1087 DEBUG_PRINT_LOW("Set Parameter called in valid state");
1088 } else {
1089 DEBUG_PRINT_ERROR("Set Parameter called in Invalid State");
1090 return OMX_ErrorIncorrectStateOperation;
1091 }
1092
1093 if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1094 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1095 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
1096 } else {
1097 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1098 eRet =OMX_ErrorUnsupportedSetting;
1099 }
1100 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc.secure",OMX_MAX_STRINGNAME_SIZE)) {
1101 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1102 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
1103 } else {
1104 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s\n", comp_role->cRole);
1105 eRet =OMX_ErrorUnsupportedSetting;
1106 }
1107 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) {
1108 if (!strncmp((const char*)comp_role->cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) {
1109 strlcpy((char*)m_cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE);
1110 } else {
1111 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1112 eRet = OMX_ErrorUnsupportedSetting;
1113 }
1114 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.h263",OMX_MAX_STRINGNAME_SIZE)) {
1115 if (!strncmp((const char*)comp_role->cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE)) {
1116 strlcpy((char*)m_cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE);
1117 } else {
1118 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1119 eRet =OMX_ErrorUnsupportedSetting;
1120 }
1121 }
1122 #ifdef _MSM8974_
1123 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) {
1124 if (!strncmp((const char*)comp_role->cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) {
1125 strlcpy((char*)m_cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE);
1126 } else {
1127 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1128 eRet =OMX_ErrorUnsupportedSetting;
1129 }
1130 }
1131 #endif
1132 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) {
1133 if (!strncmp((const char*)comp_role->cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) {
1134 strlcpy((char*)m_cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE);
1135 } else {
1136 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1137 eRet = OMX_ErrorUnsupportedSetting;
1138 }
1139 }
1140
1141 else {
1142 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %s", m_nkind);
1143 eRet = OMX_ErrorInvalidComponentName;
1144 }
1145 break;
1146 }
1147
1148 case OMX_IndexParamPriorityMgmt:
1149 {
1150 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PRIORITYMGMTTYPE);
1151 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt");
1152 if (m_state != OMX_StateLoaded) {
1153 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State");
1154 return OMX_ErrorIncorrectStateOperation;
1155 }
1156 OMX_PRIORITYMGMTTYPE *priorityMgmtype = (OMX_PRIORITYMGMTTYPE*) paramData;
1157 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt %u",
1158 (unsigned int)priorityMgmtype->nGroupID);
1159
1160 DEBUG_PRINT_LOW("set_parameter: priorityMgmtype %u",
1161 (unsigned int)priorityMgmtype->nGroupPriority);
1162
1163 m_sPriorityMgmt.nGroupID = priorityMgmtype->nGroupID;
1164 m_sPriorityMgmt.nGroupPriority = priorityMgmtype->nGroupPriority;
1165
1166 break;
1167 }
1168
1169 case OMX_IndexParamCompBufferSupplier:
1170 {
1171 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_BUFFERSUPPLIERTYPE);
1172 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier");
1173 OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
1174 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier %d",
1175 bufferSupplierType->eBufferSupplier);
1176 if (bufferSupplierType->nPortIndex == 0 || bufferSupplierType->nPortIndex ==1)
1177 m_sInBufSupplier.eBufferSupplier = bufferSupplierType->eBufferSupplier;
1178
1179 else
1180
1181 eRet = OMX_ErrorBadPortIndex;
1182
1183 break;
1184
1185 }
1186 case OMX_GoogleAndroidIndexAllocateNativeHandle:
1187 {
1188 VALIDATE_OMX_PARAM_DATA(paramData, AllocateNativeHandleParams);
1189
1190 AllocateNativeHandleParams* allocateNativeHandleParams = (AllocateNativeHandleParams *) paramData;
1191
1192 if (!secure_session) {
1193 DEBUG_PRINT_HIGH("Enable/Disable allocate-native-handle allowed only in secure session");
1194 eRet = OMX_ErrorUnsupportedSetting;
1195 break;
1196 } else if (allocateNativeHandleParams->nPortIndex != PORT_INDEX_OUT) {
1197 DEBUG_PRINT_HIGH("Enable/Disable allocate-native-handle allowed only on Output port!");
1198 eRet = OMX_ErrorUnsupportedSetting;
1199 break;
1200 } else if (m_out_mem_ptr) {
1201 DEBUG_PRINT_ERROR("Enable/Disable allocate-native-handle is not allowed since Output port is not free !");
1202 eRet = OMX_ErrorInvalidState;
1203 break;
1204 }
1205
1206 if (allocateNativeHandleParams != NULL) {
1207 allocate_native_handle = allocateNativeHandleParams->enable;
1208 }
1209 break;
1210 }
1211 case OMX_IndexParamVideoQuantization:
1212 {
1213 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
1214 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoQuantization");
1215 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *session_qp = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) paramData;
1216 if (session_qp->nPortIndex == PORT_INDEX_OUT) {
1217 if (handle->venc_set_param(paramData, OMX_IndexParamVideoQuantization) != true) {
1218 return OMX_ErrorUnsupportedSetting;
1219 }
1220 m_sSessionQuantization.nQpI = session_qp->nQpI;
1221 m_sSessionQuantization.nQpP = session_qp->nQpP;
1222 m_sSessionQuantization.nQpB = session_qp->nQpB;
1223 } else {
1224 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for Session QP setting");
1225 eRet = OMX_ErrorBadPortIndex;
1226 }
1227 break;
1228 }
1229
1230 case OMX_QcomIndexParamVideoQPRange:
1231 {
1232 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_QPRANGETYPE);
1233 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexParamVideoQPRange");
1234 OMX_QCOM_VIDEO_PARAM_QPRANGETYPE *qp_range = (OMX_QCOM_VIDEO_PARAM_QPRANGETYPE*) paramData;
1235 if (qp_range->nPortIndex == PORT_INDEX_OUT) {
1236 if (handle->venc_set_param(paramData,
1237 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoQPRange) != true) {
1238 return OMX_ErrorUnsupportedSetting;
1239 }
1240 m_sSessionQPRange.minQP= qp_range->minQP;
1241 m_sSessionQPRange.maxQP= qp_range->maxQP;
1242 } else {
1243 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for QP range setting");
1244 eRet = OMX_ErrorBadPortIndex;
1245 }
1246 break;
1247 }
1248
1249 case OMX_QcomIndexParamVideoIPBQPRange:
1250 {
1251 DEBUG_PRINT_LOW("set_parameter: OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE");
1252 OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE *qp_range = (OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE*) paramData;
1253 if (qp_range->nPortIndex == PORT_INDEX_OUT) {
1254 if (handle->venc_set_param(paramData,
1255 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoIPBQPRange) != true) {
1256 return OMX_ErrorUnsupportedSetting;
1257 }
1258 m_sSessionIPBQPRange.minIQP = qp_range->minIQP;
1259 m_sSessionIPBQPRange.maxIQP = qp_range->maxIQP;
1260 m_sSessionIPBQPRange.minPQP = qp_range->minPQP;
1261 m_sSessionIPBQPRange.maxPQP = qp_range->maxPQP;
1262 m_sSessionIPBQPRange.minBQP = qp_range->minBQP;
1263 m_sSessionIPBQPRange.maxBQP = qp_range->maxBQP;
1264 } else {
1265 DEBUG_PRINT_ERROR("Unsupported port Index for IPB QP range setting");
1266 eRet = OMX_ErrorBadPortIndex;
1267 }
1268 break;
1269 }
1270
1271 case OMX_QcomIndexPortDefn:
1272 {
1273 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_PARAM_PORTDEFINITIONTYPE);
1274 OMX_QCOM_PARAM_PORTDEFINITIONTYPE* pParam =
1275 (OMX_QCOM_PARAM_PORTDEFINITIONTYPE*)paramData;
1276 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexPortDefn");
1277 if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_IN) {
1278 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid &&
1279 pParam->nMemRegion < OMX_QCOM_MemRegionMax) {
1280 m_use_input_pmem = OMX_TRUE;
1281 } else {
1282 m_use_input_pmem = OMX_FALSE;
1283 }
1284 } else if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_OUT) {
1285 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid &&
1286 pParam->nMemRegion < OMX_QCOM_MemRegionMax) {
1287 m_use_output_pmem = OMX_TRUE;
1288 } else {
1289 m_use_output_pmem = OMX_FALSE;
1290 }
1291 } else {
1292 DEBUG_PRINT_ERROR("ERROR: SetParameter called on unsupported Port Index for QcomPortDefn");
1293 return OMX_ErrorBadPortIndex;
1294 }
1295 break;
1296 }
1297
1298 case OMX_IndexParamVideoErrorCorrection:
1299 {
1300 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
1301 DEBUG_PRINT_LOW("OMX_IndexParamVideoErrorCorrection");
1302 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* pParam =
1303 (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)paramData;
1304 if (!handle->venc_set_param(paramData, OMX_IndexParamVideoErrorCorrection)) {
1305 DEBUG_PRINT_ERROR("ERROR: Request for setting Error Resilience failed");
1306 return OMX_ErrorUnsupportedSetting;
1307 }
1308 memcpy(&m_sErrorCorrection,pParam, sizeof(m_sErrorCorrection));
1309 break;
1310 }
1311 case OMX_IndexParamVideoIntraRefresh:
1312 {
1313 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
1314 DEBUG_PRINT_LOW("set_param:OMX_IndexParamVideoIntraRefresh");
1315 OMX_VIDEO_PARAM_INTRAREFRESHTYPE* pParam =
1316 (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*)paramData;
1317 if (!handle->venc_set_param(paramData,OMX_IndexParamVideoIntraRefresh)) {
1318 DEBUG_PRINT_ERROR("ERROR: Request for setting intra refresh failed");
1319 return OMX_ErrorUnsupportedSetting;
1320 }
1321 memcpy(&m_sIntraRefresh, pParam, sizeof(m_sIntraRefresh));
1322 break;
1323 }
1324 #ifdef _ANDROID_ICS_
1325 case OMX_QcomIndexParamVideoMetaBufferMode:
1326 {
1327 VALIDATE_OMX_PARAM_DATA(paramData, StoreMetaDataInBuffersParams);
1328 StoreMetaDataInBuffersParams *pParam =
1329 (StoreMetaDataInBuffersParams*)paramData;
1330 DEBUG_PRINT_HIGH("set_parameter:OMX_QcomIndexParamVideoMetaBufferMode: "
1331 "port_index = %u, meta_mode = %d", (unsigned int)pParam->nPortIndex, pParam->bStoreMetaData);
1332 if (pParam->nPortIndex == PORT_INDEX_IN) {
1333 if (pParam->bStoreMetaData != meta_mode_enable) {
1334 if (!handle->venc_set_meta_mode(pParam->bStoreMetaData)) {
1335 DEBUG_PRINT_ERROR("ERROR: set Metabuffer mode %d fail",
1336 pParam->bStoreMetaData);
1337 return OMX_ErrorUnsupportedSetting;
1338 }
1339 meta_mode_enable = pParam->bStoreMetaData;
1340 if (meta_mode_enable) {
1341 m_sInPortDef.nBufferCountActual = m_sInPortDef.nBufferCountMin;
1342 if (handle->venc_set_param(&m_sInPortDef,OMX_IndexParamPortDefinition) != true) {
1343 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed");
1344 return OMX_ErrorUnsupportedSetting;
1345 }
1346 } else {
1347 /*TODO: reset encoder driver Meta mode*/
1348 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin,
1349 &m_sOutPortDef.nBufferCountActual,
1350 &m_sOutPortDef.nBufferSize,
1351 m_sOutPortDef.nPortIndex);
1352 }
1353 }
1354 } else if (pParam->nPortIndex == PORT_INDEX_OUT && secure_session) {
1355 DEBUG_PRINT_ERROR("set_parameter: metamode is "
1356 "valid for input port only in secure session");
1357 return OMX_ErrorUnsupportedSetting;
1358 } else {
1359 DEBUG_PRINT_HIGH("set_parameter: metamode is "
1360 "valid for input port only");
1361 eRet = OMX_ErrorUnsupportedIndex;
1362 }
1363 }
1364 break;
1365 #endif
1366 #if !defined(MAX_RES_720P) || defined(_MSM8974_)
1367 case OMX_QcomIndexParamIndexExtraDataType:
1368 {
1369 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_INDEXEXTRADATATYPE);
1370 DEBUG_PRINT_HIGH("set_parameter: OMX_QcomIndexParamIndexExtraDataType");
1371 QOMX_INDEXEXTRADATATYPE *pParam = (QOMX_INDEXEXTRADATATYPE *)paramData;
1372 bool enable = false;
1373 OMX_U32 mask = 0;
1374
1375 if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderSliceInfo) {
1376 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1377 mask = VENC_EXTRADATA_SLICEINFO;
1378
1379 DEBUG_PRINT_HIGH("SliceInfo extradata %s",
1380 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1381 } else {
1382 DEBUG_PRINT_ERROR("set_parameter: Slice information is "
1383 "valid for output port only");
1384 eRet = OMX_ErrorUnsupportedIndex;
1385 break;
1386 }
1387 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderMBInfo) {
1388 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1389 mask = VENC_EXTRADATA_MBINFO;
1390
1391 DEBUG_PRINT_HIGH("MBInfo extradata %s",
1392 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1393 } else {
1394 DEBUG_PRINT_ERROR("set_parameter: MB information is "
1395 "valid for output port only");
1396 eRet = OMX_ErrorUnsupportedIndex;
1397 break;
1398 }
1399 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataFrameDimension) {
1400 if (pParam->nPortIndex == PORT_INDEX_IN) {
1401 mask = VENC_EXTRADATA_FRAMEDIMENSION;
1402 DEBUG_PRINT_HIGH("Frame dimension extradata %s",
1403 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1404 } else {
1405 DEBUG_PRINT_ERROR("set_parameter: Frame Dimension is "
1406 "valid for input port only");
1407 eRet = OMX_ErrorUnsupportedIndex;
1408 break;
1409 }
1410 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_QTIIndexParamVQZipSEIExtraData) {
1411 if (pParam->nPortIndex == PORT_INDEX_IN) {
1412 mask = VENC_EXTRADATA_VQZIP;
1413 DEBUG_PRINT_HIGH("VQZIP extradata %s",
1414 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1415 } else {
1416 DEBUG_PRINT_ERROR("set_parameter: VQZIP is "
1417 "valid for input port only");
1418 eRet = OMX_ErrorUnsupportedIndex;
1419 break;
1420 }
1421 }
1422 else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoLTRInfo) {
1423 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1424 if (pParam->bEnabled == OMX_TRUE)
1425 mask = VEN_EXTRADATA_LTRINFO;
1426
1427 DEBUG_PRINT_HIGH("LTRInfo extradata %s",
1428 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1429 } else {
1430 DEBUG_PRINT_ERROR("set_parameter: LTR information is "
1431 "valid for output port only");
1432 eRet = OMX_ErrorUnsupportedIndex;
1433 break;
1434 }
1435 }
1436 else {
1437 DEBUG_PRINT_ERROR("set_parameter: unsupported extrdata index (%x)",
1438 pParam->nIndex);
1439 eRet = OMX_ErrorUnsupportedIndex;
1440 break;
1441 }
1442
1443
1444 if (pParam->bEnabled == OMX_TRUE)
1445 m_sExtraData |= mask;
1446 else
1447 m_sExtraData &= ~mask;
1448
1449 enable = !!(m_sExtraData & mask);
1450 if (handle->venc_set_param(&enable,
1451 (OMX_INDEXTYPE)pParam->nIndex) != true) {
1452 DEBUG_PRINT_ERROR("ERROR: Setting Extradata (%x) failed", pParam->nIndex);
1453 return OMX_ErrorUnsupportedSetting;
1454 }
1455
1456 if (pParam->nPortIndex == PORT_INDEX_IN) {
1457 m_sInPortDef.nPortIndex = PORT_INDEX_IN;
1458 dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
1459 &m_sInPortDef.nBufferCountActual,
1460 &m_sInPortDef.nBufferSize,
1461 m_sInPortDef.nPortIndex);
1462 DEBUG_PRINT_HIGH("updated in_buf_req: buffer cnt=%u, "
1463 "count min=%u, buffer size=%u",
1464 (unsigned int)m_sOutPortDef.nBufferCountActual,
1465 (unsigned int)m_sOutPortDef.nBufferCountMin,
1466 (unsigned int)m_sOutPortDef.nBufferSize);
1467
1468 } else {
1469 m_sOutPortDef.nPortIndex = PORT_INDEX_OUT;
1470 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
1471 &m_sOutPortDef.nBufferCountActual,
1472 &m_sOutPortDef.nBufferSize,
1473 m_sOutPortDef.nPortIndex);
1474 DEBUG_PRINT_HIGH("updated out_buf_req: buffer cnt=%u, "
1475 "count min=%u, buffer size=%u",
1476 (unsigned int)m_sOutPortDef.nBufferCountActual,
1477 (unsigned int)m_sOutPortDef.nBufferCountMin,
1478 (unsigned int)m_sOutPortDef.nBufferSize);
1479 }
1480 break;
1481 }
1482 case QOMX_IndexParamVideoLTRMode:
1483 {
1484 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_LTRMODE_TYPE);
1485 QOMX_VIDEO_PARAM_LTRMODE_TYPE* pParam =
1486 (QOMX_VIDEO_PARAM_LTRMODE_TYPE*)paramData;
1487 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRMode)) {
1488 DEBUG_PRINT_ERROR("ERROR: Setting LTR mode failed");
1489 return OMX_ErrorUnsupportedSetting;
1490 }
1491 memcpy(&m_sParamLTRMode, pParam, sizeof(m_sParamLTRMode));
1492 break;
1493 }
1494 case QOMX_IndexParamVideoLTRCount:
1495 {
1496 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_LTRCOUNT_TYPE);
1497 QOMX_VIDEO_PARAM_LTRCOUNT_TYPE* pParam =
1498 (QOMX_VIDEO_PARAM_LTRCOUNT_TYPE*)paramData;
1499 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRCount)) {
1500 DEBUG_PRINT_ERROR("ERROR: Setting LTR count failed");
1501 return OMX_ErrorUnsupportedSetting;
1502 }
1503 memcpy(&m_sParamLTRCount, pParam, sizeof(m_sParamLTRCount));
1504 break;
1505 }
1506 #endif
1507 case OMX_QcomIndexParamVideoMaxAllowedBitrateCheck:
1508 {
1509 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1510 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1511 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1512 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1513 handle->m_max_allowed_bitrate_check =
1514 ((pParam->bEnable == OMX_TRUE) ? true : false);
1515 DEBUG_PRINT_HIGH("set_parameter: max allowed bitrate check %s",
1516 ((pParam->bEnable == OMX_TRUE) ? "enabled" : "disabled"));
1517 } else {
1518 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexParamVideoMaxAllowedBitrateCheck "
1519 " called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1520 return OMX_ErrorBadPortIndex;
1521 }
1522 break;
1523 }
1524 #ifdef MAX_RES_1080P
1525 case OMX_QcomIndexEnableSliceDeliveryMode:
1526 {
1527 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1528 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1529 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1530 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1531 if (!handle->venc_set_param(paramData,
1532 (OMX_INDEXTYPE)OMX_QcomIndexEnableSliceDeliveryMode)) {
1533 DEBUG_PRINT_ERROR("ERROR: Request for setting slice delivery mode failed");
1534 return OMX_ErrorUnsupportedSetting;
1535 }
1536 } else {
1537 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableSliceDeliveryMode "
1538 "called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1539 return OMX_ErrorBadPortIndex;
1540 }
1541 break;
1542 }
1543 #endif
1544 case OMX_QcomIndexEnableH263PlusPType:
1545 {
1546 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1547 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1548 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1549 DEBUG_PRINT_LOW("OMX_QcomIndexEnableH263PlusPType");
1550 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1551 if (!handle->venc_set_param(paramData,
1552 (OMX_INDEXTYPE)OMX_QcomIndexEnableH263PlusPType)) {
1553 DEBUG_PRINT_ERROR("ERROR: Request for setting PlusPType failed");
1554 return OMX_ErrorUnsupportedSetting;
1555 }
1556 } else {
1557 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableH263PlusPType "
1558 "called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1559 return OMX_ErrorBadPortIndex;
1560 }
1561 break;
1562 }
1563 case OMX_QcomIndexParamSequenceHeaderWithIDR:
1564 {
1565 VALIDATE_OMX_PARAM_DATA(paramData, PrependSPSPPSToIDRFramesParams);
1566 if(!handle->venc_set_param(paramData,
1567 (OMX_INDEXTYPE)OMX_QcomIndexParamSequenceHeaderWithIDR)) {
1568 DEBUG_PRINT_ERROR("%s: %s",
1569 "OMX_QComIndexParamSequenceHeaderWithIDR:",
1570 "request for inband sps/pps failed.");
1571 return OMX_ErrorUnsupportedSetting;
1572 }
1573 memcpy(&m_sPrependSPSPPS, paramData, sizeof(m_sPrependSPSPPS));
1574 break;
1575 }
1576 case OMX_QcomIndexParamH264AUDelimiter:
1577 {
1578 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_CONFIG_H264_AUD);
1579 if(!handle->venc_set_param(paramData,
1580 (OMX_INDEXTYPE)OMX_QcomIndexParamH264AUDelimiter)) {
1581 DEBUG_PRINT_ERROR("%s: %s",
1582 "OMX_QComIndexParamh264AUDelimiter:",
1583 "request for AU Delimiters failed.");
1584 return OMX_ErrorUnsupportedSetting;
1585 }
1586 break;
1587 }
1588 case OMX_QcomIndexParamMBIStatisticsMode:
1589 {
1590 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QOMX_VIDEO_MBI_STATISTICS);
1591 if(!handle->venc_set_param(paramData,
1592 (OMX_INDEXTYPE)OMX_QcomIndexParamMBIStatisticsMode)) {
1593 DEBUG_PRINT_ERROR("%s: %s",
1594 "OMX_QcomIndexParamMBIStatisticsMode:",
1595 "MBI Statistics mode setting failed.");
1596 return OMX_ErrorUnsupportedSetting;
1597 }
1598 break;
1599 }
1600 case OMX_QcomIndexHierarchicalStructure:
1601 {
1602 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_HIERARCHICALLAYERS);
1603 QOMX_VIDEO_HIERARCHICALLAYERS* pParam =
1604 (QOMX_VIDEO_HIERARCHICALLAYERS*)paramData;
1605 DEBUG_PRINT_LOW("OMX_QcomIndexHierarchicalStructure");
1606 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1607 if (!handle->venc_set_param(paramData,
1608 (OMX_INDEXTYPE)OMX_QcomIndexHierarchicalStructure)) {
1609 DEBUG_PRINT_ERROR("ERROR: Request for setting PlusPType failed");
1610 return OMX_ErrorUnsupportedSetting;
1611 }
1612 if((pParam->eHierarchicalCodingType == QOMX_HIERARCHICALCODING_B) && pParam->nNumLayers)
1613 hier_b_enabled = true;
1614 m_sHierLayers.nNumLayers = pParam->nNumLayers;
1615 m_sHierLayers.eHierarchicalCodingType = pParam->eHierarchicalCodingType;
1616 } else {
1617 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexHierarchicalStructure called on wrong port(%u)",
1618 (unsigned int)pParam->nPortIndex);
1619 return OMX_ErrorBadPortIndex;
1620 }
1621 break;
1622
1623 }
1624 case OMX_QcomIndexParamPerfLevel:
1625 {
1626 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_PERF_LEVEL);
1627 if (!handle->venc_set_param(paramData,
1628 (OMX_INDEXTYPE) OMX_QcomIndexParamPerfLevel)) {
1629 DEBUG_PRINT_ERROR("ERROR: Setting performance level");
1630 return OMX_ErrorUnsupportedSetting;
1631 }
1632 break;
1633 }
1634 case OMX_QcomIndexParamH264VUITimingInfo:
1635 {
1636 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_VUI_TIMING_INFO);
1637 if (!handle->venc_set_param(paramData,
1638 (OMX_INDEXTYPE) OMX_QcomIndexParamH264VUITimingInfo)) {
1639 DEBUG_PRINT_ERROR("ERROR: Setting VUI timing info");
1640 return OMX_ErrorUnsupportedSetting;
1641 }
1642 break;
1643 }
1644 case OMX_QcomIndexParamPeakBitrate:
1645 {
1646 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_PEAK_BITRATE);
1647 if (!handle->venc_set_param(paramData,
1648 (OMX_INDEXTYPE) OMX_QcomIndexParamPeakBitrate)) {
1649 DEBUG_PRINT_ERROR("ERROR: Setting peak bitrate");
1650 return OMX_ErrorUnsupportedSetting;
1651 }
1652 break;
1653 }
1654 case QOMX_IndexParamVideoInitialQp:
1655 {
1656 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_INITIALQP);
1657 if(!handle->venc_set_param(paramData,
1658 (OMX_INDEXTYPE)QOMX_IndexParamVideoInitialQp)) {
1659 DEBUG_PRINT_ERROR("Request to Enable initial QP failed");
1660 return OMX_ErrorUnsupportedSetting;
1661 }
1662 memcpy(&m_sParamInitqp, paramData, sizeof(m_sParamInitqp));
1663 break;
1664 }
1665 case OMX_QcomIndexParamSetMVSearchrange:
1666 {
1667 if (!handle->venc_set_param(paramData,
1668 (OMX_INDEXTYPE) OMX_QcomIndexParamSetMVSearchrange)) {
1669 DEBUG_PRINT_ERROR("ERROR: Setting Searchrange");
1670 return OMX_ErrorUnsupportedSetting;
1671 }
1672 break;
1673 }
1674 case OMX_QcomIndexParamVideoHybridHierpMode:
1675 {
1676 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_HYBRID_HP_MODE);
1677 if(!handle->venc_set_param(paramData,
1678 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoHybridHierpMode)) {
1679 DEBUG_PRINT_ERROR("Request to Enable Hybrid Hier-P failed");
1680 return OMX_ErrorUnsupportedSetting;
1681 }
1682 break;
1683 }
1684 case OMX_QcomIndexParamBatchSize:
1685 {
1686 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_U32TYPE);
1687 if(!handle->venc_set_param(paramData,
1688 (OMX_INDEXTYPE)OMX_QcomIndexParamBatchSize)) {
1689 DEBUG_PRINT_ERROR("Attempting to set batch size failed");
1690 return OMX_ErrorUnsupportedSetting;
1691 }
1692 break;
1693 }
1694 case OMX_QcomIndexConfigH264EntropyCodingCabac:
1695 {
1696 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_H264ENTROPYCODINGTYPE);
1697 if(!handle->venc_set_param(paramData,
1698 (OMX_INDEXTYPE)OMX_QcomIndexConfigH264EntropyCodingCabac)) {
1699 DEBUG_PRINT_ERROR("Attempting to set Entropy failed");
1700 return OMX_ErrorUnsupportedSetting;
1701 }
1702 break;
1703 }
1704 case OMX_QTIIndexParamVQZIPSEIType:
1705 {
1706 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QTI_VIDEO_PARAM_VQZIP_SEI_TYPE);
1707 if (!handle->venc_set_param(paramData,
1708 (OMX_INDEXTYPE) OMX_QTIIndexParamVQZIPSEIType)) {
1709 DEBUG_PRINT_ERROR("ERROR: Setting VQZIP SEI type");
1710 return OMX_ErrorUnsupportedSetting;
1711 }
1712 m_sExtraData |= VENC_EXTRADATA_VQZIP;
1713 break;
1714 }
1715 case OMX_QcomIndexParamVencAspectRatio:
1716 {
1717 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_VENC_SAR);
1718 if (!handle->venc_set_param(paramData,
1719 (OMX_INDEXTYPE)OMX_QcomIndexParamVencAspectRatio)) {
1720 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexParamVencAspectRatio failed");
1721 return OMX_ErrorUnsupportedSetting;
1722 }
1723 memcpy(&m_sSar, paramData, sizeof(m_sSar));
1724 break;
1725 }
1726 case OMX_QTIIndexParamLowLatencyMode:
1727 {
1728 if (!handle->venc_set_param(paramData,
1729 (OMX_INDEXTYPE)OMX_QTIIndexParamLowLatencyMode)) {
1730 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamLowLatencyMode failed");
1731 return OMX_ErrorUnsupportedSetting;
1732 }
1733 memcpy(&m_slowLatencyMode, paramData, sizeof(m_slowLatencyMode));
1734 break;
1735 }
1736 case OMX_QcomIndexConfigVideoVencLowLatencyMode:
1737 {
1738 if(!handle->venc_set_param(paramData,
1739 (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencLowLatencyMode)) {
1740 DEBUG_PRINT_ERROR("Request to Enable Low latency mode failed");
1741 return OMX_ErrorUnsupportedSetting;
1742 }
1743 break;
1744 }
1745 case OMX_QTIIndexParamVideoEnableRoiInfo:
1746 {
1747 if (!handle->venc_set_param(paramData,
1748 (OMX_INDEXTYPE)OMX_QTIIndexParamVideoEnableRoiInfo)) {
1749 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamVideoEnableRoiInfo failed");
1750 return OMX_ErrorUnsupportedSetting;
1751 }
1752 m_sExtraData |= VENC_EXTRADATA_ROI;
1753 break;
1754 }
1755 case OMX_IndexParamAndroidVideoTemporalLayering:
1756 {
1757 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE);
1758 if (!handle->venc_set_param(paramData,
1759 (OMX_INDEXTYPE)OMX_IndexParamAndroidVideoTemporalLayering)) {
1760 DEBUG_PRINT_ERROR("Failed to configure temporal layers");
1761 return OMX_ErrorUnsupportedSetting;
1762 }
1763 // save the actual configuration applied
1764 memcpy(&m_sParamTemporalLayers, paramData, sizeof(m_sParamTemporalLayers));
1765 // keep the config data in sync
1766 m_sConfigTemporalLayers.ePattern = m_sParamTemporalLayers.ePattern;
1767 m_sConfigTemporalLayers.nBLayerCountActual = m_sParamTemporalLayers.nBLayerCountActual;
1768 m_sConfigTemporalLayers.nPLayerCountActual = m_sParamTemporalLayers.nPLayerCountActual;
1769 m_sConfigTemporalLayers.bBitrateRatiosSpecified = m_sParamTemporalLayers.bBitrateRatiosSpecified;
1770 memcpy(&m_sConfigTemporalLayers.nBitrateRatios[0],
1771 &m_sParamTemporalLayers.nBitrateRatios[0],
1772 OMX_VIDEO_ANDROID_MAXTEMPORALLAYERS * sizeof(OMX_U32));
1773 break;
1774 }
1775 case OMX_QTIIndexParamDisablePQ:
1776 {
1777 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_DISABLETYPE);
1778 handle->venc_set_param(paramData,
1779 (OMX_INDEXTYPE)OMX_QTIIndexParamDisablePQ);
1780 break;
1781 }
1782 case OMX_QTIIndexParamIframeSizeType:
1783 {
1784 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_IFRAMESIZE);
1785 if (!handle->venc_set_param(paramData,
1786 (OMX_INDEXTYPE)OMX_QTIIndexParamIframeSizeType)) {
1787 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamIframeSizeType failed");
1788 return OMX_ErrorUnsupportedSetting;
1789 }
1790 break;
1791 }
1792 case OMX_QTIIndexParamEnableAVTimerTimestamps:
1793 {
1794 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_ENABLETYPE);
1795 if (!handle->venc_set_param(paramData,
1796 (OMX_INDEXTYPE)OMX_QTIIndexParamEnableAVTimerTimestamps)) {
1797 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamEnableAVTimerTimestamps failed");
1798 return OMX_ErrorUnsupportedSetting;
1799 }
1800 memcpy(&m_sParamAVTimerTimestampMode, paramData, sizeof(QOMX_ENABLETYPE));
1801 break;
1802 }
1803 case OMX_IndexParamVideoSliceFMO:
1804 default:
1805 {
1806 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %d", paramIndex);
1807 eRet = OMX_ErrorUnsupportedIndex;
1808 break;
1809 }
1810 }
1811 return eRet;
1812 }
1813
update_profile_level()1814 bool omx_venc::update_profile_level()
1815 {
1816 OMX_U32 eProfile, eLevel;
1817
1818 if (!handle->venc_get_profile_level(&eProfile,&eLevel)) {
1819 DEBUG_PRINT_ERROR("Failed to update the profile_level");
1820 return false;
1821 }
1822
1823 m_sParamProfileLevel.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile;
1824 m_sParamProfileLevel.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel;
1825
1826 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\
1827 OMX_MAX_STRINGNAME_SIZE)) {
1828 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile;
1829 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel;
1830 DEBUG_PRINT_LOW("MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile,
1831 m_sParamMPEG4.eLevel);
1832 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\
1833 OMX_MAX_STRINGNAME_SIZE)) {
1834 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)eProfile;
1835 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)eLevel;
1836 DEBUG_PRINT_LOW("H263 profile = %d, level = %d", m_sParamH263.eProfile,
1837 m_sParamH263.eLevel);
1838 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
1839 OMX_MAX_STRINGNAME_SIZE)) {
1840 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile;
1841 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel;
1842 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1843 m_sParamAVC.eLevel);
1844 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
1845 OMX_MAX_STRINGNAME_SIZE)) {
1846 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile;
1847 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel;
1848 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1849 m_sParamAVC.eLevel);
1850 }
1851 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.vp8",\
1852 OMX_MAX_STRINGNAME_SIZE)) {
1853 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)eProfile;
1854 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)eLevel;
1855 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile,
1856 m_sParamVP8.eLevel);
1857 }
1858 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc",\
1859 OMX_MAX_STRINGNAME_SIZE)) {
1860 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)eProfile;
1861 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)eLevel;
1862 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile,
1863 m_sParamHEVC.eLevel);
1864 }
1865
1866 return true;
1867 }
1868 /* ======================================================================
1869 FUNCTION
1870 omx_video::SetConfig
1871
1872 DESCRIPTION
1873 OMX Set Config method implementation
1874
1875 PARAMETERS
1876 <TBD>.
1877
1878 RETURN VALUE
1879 OMX Error None if successful.
1880 ========================================================================== */
set_config(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_INDEXTYPE configIndex,OMX_IN OMX_PTR configData)1881 OMX_ERRORTYPE omx_venc::set_config(OMX_IN OMX_HANDLETYPE hComp,
1882 OMX_IN OMX_INDEXTYPE configIndex,
1883 OMX_IN OMX_PTR configData)
1884 {
1885 (void)hComp;
1886 if (configData == NULL) {
1887 DEBUG_PRINT_ERROR("ERROR: param is null");
1888 return OMX_ErrorBadParameter;
1889 }
1890
1891 if (m_state == OMX_StateInvalid) {
1892 DEBUG_PRINT_ERROR("ERROR: config called in Invalid state");
1893 return OMX_ErrorIncorrectStateOperation;
1894 }
1895
1896 // params will be validated prior to venc_init
1897 switch ((int)configIndex) {
1898 case OMX_IndexConfigVideoBitrate:
1899 {
1900 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_BITRATETYPE);
1901 OMX_VIDEO_CONFIG_BITRATETYPE* pParam =
1902 reinterpret_cast<OMX_VIDEO_CONFIG_BITRATETYPE*>(configData);
1903 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoBitrate (%u)", (unsigned int)pParam->nEncodeBitrate);
1904
1905 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1906 if (handle->venc_set_config(configData, OMX_IndexConfigVideoBitrate) != true) {
1907 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoBitrate failed");
1908 return OMX_ErrorUnsupportedSetting;
1909 }
1910
1911 m_sConfigBitrate.nEncodeBitrate = pParam->nEncodeBitrate;
1912 m_sParamBitrate.nTargetBitrate = pParam->nEncodeBitrate;
1913 m_sOutPortDef.format.video.nBitrate = pParam->nEncodeBitrate;
1914 } else {
1915 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1916 return OMX_ErrorBadPortIndex;
1917 }
1918 break;
1919 }
1920 case OMX_IndexConfigVideoFramerate:
1921 {
1922 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_FRAMERATETYPE);
1923 OMX_CONFIG_FRAMERATETYPE* pParam =
1924 reinterpret_cast<OMX_CONFIG_FRAMERATETYPE*>(configData);
1925 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoFramerate (0x%x)", (unsigned int)pParam->xEncodeFramerate);
1926
1927 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1928 if (handle->venc_set_config(configData, OMX_IndexConfigVideoFramerate) != true) {
1929 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoFramerate failed");
1930 return OMX_ErrorUnsupportedSetting;
1931 }
1932
1933 m_sConfigFramerate.xEncodeFramerate = pParam->xEncodeFramerate;
1934 m_sOutPortDef.format.video.xFramerate = pParam->xEncodeFramerate;
1935 m_sOutPortFormat.xFramerate = pParam->xEncodeFramerate;
1936 /*
1937 * Frame rate can change buffer requirements. If query is not allowed,
1938 * failure is not FATAL here.
1939 */
1940 dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
1941 &m_sInPortDef.nBufferCountActual,
1942 &m_sInPortDef.nBufferSize,
1943 m_sInPortDef.nPortIndex);
1944 } else {
1945 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1946 return OMX_ErrorBadPortIndex;
1947 }
1948
1949 break;
1950 }
1951 case QOMX_IndexConfigVideoIntraperiod:
1952 {
1953 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_INTRAPERIODTYPE);
1954 QOMX_VIDEO_INTRAPERIODTYPE* pParam =
1955 reinterpret_cast<QOMX_VIDEO_INTRAPERIODTYPE*>(configData);
1956
1957 DEBUG_PRINT_HIGH("set_config(): QOMX_IndexConfigVideoIntraperiod");
1958 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1959 #ifdef MAX_RES_720P
1960 if (pParam->nBFrames > 0) {
1961 DEBUG_PRINT_ERROR("B frames not supported");
1962 return OMX_ErrorUnsupportedSetting;
1963 }
1964 #endif
1965 DEBUG_PRINT_HIGH("Old: P/B frames = %u/%u, New: P/B frames = %u/%u",
1966 (unsigned int)m_sIntraperiod.nPFrames, (unsigned int)m_sIntraperiod.nBFrames,
1967 (unsigned int)pParam->nPFrames, (unsigned int)pParam->nBFrames);
1968 if (m_sIntraperiod.nBFrames != pParam->nBFrames) {
1969 if(hier_b_enabled && m_state == OMX_StateLoaded) {
1970 DEBUG_PRINT_INFO("B-frames setting is supported if HierB is enabled");
1971 }
1972 }
1973 if (handle->venc_set_config(configData, (OMX_INDEXTYPE) QOMX_IndexConfigVideoIntraperiod) != true) {
1974 DEBUG_PRINT_ERROR("ERROR: Setting QOMX_IndexConfigVideoIntraperiod failed");
1975 return OMX_ErrorUnsupportedSetting;
1976 }
1977 m_sIntraperiod.nPFrames = pParam->nPFrames;
1978 m_sIntraperiod.nBFrames = pParam->nBFrames;
1979 m_sIntraperiod.nIDRPeriod = pParam->nIDRPeriod;
1980
1981 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
1982 m_sParamMPEG4.nPFrames = pParam->nPFrames;
1983 if (m_sParamMPEG4.eProfile != OMX_VIDEO_MPEG4ProfileSimple)
1984 m_sParamMPEG4.nBFrames = pParam->nBFrames;
1985 else
1986 m_sParamMPEG4.nBFrames = 0;
1987 } else if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingH263) {
1988 m_sParamH263.nPFrames = pParam->nPFrames;
1989 } else {
1990 m_sParamAVC.nPFrames = pParam->nPFrames;
1991 if ((m_sParamAVC.eProfile != OMX_VIDEO_AVCProfileBaseline) &&
1992 (m_sParamAVC.eProfile != (OMX_VIDEO_AVCPROFILETYPE) OMX_VIDEO_AVCProfileConstrainedBaseline) &&
1993 (m_sParamAVC.eProfile != (OMX_VIDEO_AVCPROFILETYPE) QOMX_VIDEO_AVCProfileConstrainedBaseline))
1994 m_sParamAVC.nBFrames = pParam->nBFrames;
1995 else
1996 m_sParamAVC.nBFrames = 0;
1997 }
1998 } else {
1999 DEBUG_PRINT_ERROR("ERROR: (QOMX_IndexConfigVideoIntraperiod) Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2000 return OMX_ErrorBadPortIndex;
2001 }
2002
2003 break;
2004 }
2005
2006 case OMX_IndexConfigVideoIntraVOPRefresh:
2007 {
2008 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_INTRAREFRESHVOPTYPE);
2009 OMX_CONFIG_INTRAREFRESHVOPTYPE* pParam =
2010 reinterpret_cast<OMX_CONFIG_INTRAREFRESHVOPTYPE*>(configData);
2011
2012 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoIntraVOPRefresh");
2013 if (pParam->nPortIndex == PORT_INDEX_OUT) {
2014 if (handle->venc_set_config(configData,
2015 OMX_IndexConfigVideoIntraVOPRefresh) != true) {
2016 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoIntraVOPRefresh failed");
2017 return OMX_ErrorUnsupportedSetting;
2018 }
2019
2020 m_sConfigIntraRefreshVOP.IntraRefreshVOP = pParam->IntraRefreshVOP;
2021 } else {
2022 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2023 return OMX_ErrorBadPortIndex;
2024 }
2025
2026 break;
2027 }
2028 case OMX_IndexConfigCommonRotate:
2029 {
2030 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ROTATIONTYPE);
2031 OMX_CONFIG_ROTATIONTYPE *pParam =
2032 reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData);
2033 OMX_S32 nRotation;
2034
2035 if (pParam->nPortIndex != PORT_INDEX_OUT) {
2036 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2037 return OMX_ErrorBadPortIndex;
2038 }
2039 if ( pParam->nRotation == 0 ||
2040 pParam->nRotation == 90 ||
2041 pParam->nRotation == 180 ||
2042 pParam->nRotation == 270 ) {
2043 DEBUG_PRINT_HIGH("set_config: Rotation Angle %u", (unsigned int)pParam->nRotation);
2044 } else {
2045 DEBUG_PRINT_ERROR("ERROR: un supported Rotation %u", (unsigned int)pParam->nRotation);
2046 return OMX_ErrorUnsupportedSetting;
2047 }
2048 nRotation = pParam->nRotation - m_sConfigFrameRotation.nRotation;
2049 if (nRotation < 0)
2050 nRotation = -nRotation;
2051
2052 DEBUG_PRINT_HIGH("set_config: updating device Dims");
2053
2054 if (handle->venc_set_config(configData,
2055 OMX_IndexConfigCommonRotate) != true) {
2056 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonRotate failed");
2057 return OMX_ErrorUnsupportedSetting;
2058 }
2059 m_sConfigFrameRotation.nRotation = pParam->nRotation;
2060
2061 // Update output-port resolution (since it might have been flipped by rotation)
2062 if (handle->venc_get_dimensions(PORT_INDEX_OUT,
2063 &m_sOutPortDef.format.video.nFrameWidth,
2064 &m_sOutPortDef.format.video.nFrameHeight)) {
2065 DEBUG_PRINT_HIGH("set Rotation: updated dimensions = %u x %u",
2066 m_sOutPortDef.format.video.nFrameWidth,
2067 m_sOutPortDef.format.video.nFrameHeight);
2068 }
2069 break;
2070 }
2071 case OMX_QcomIndexConfigVideoFramePackingArrangement:
2072 {
2073 DEBUG_PRINT_HIGH("set_config(): OMX_QcomIndexConfigVideoFramePackingArrangement");
2074 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingAVC) {
2075 VALIDATE_OMX_PARAM_DATA(configData, OMX_QCOM_FRAME_PACK_ARRANGEMENT);
2076 OMX_QCOM_FRAME_PACK_ARRANGEMENT *configFmt =
2077 (OMX_QCOM_FRAME_PACK_ARRANGEMENT *) configData;
2078 extra_data_handle.set_frame_pack_data(configFmt);
2079 } else {
2080 DEBUG_PRINT_ERROR("ERROR: FramePackingData not supported for non AVC compression");
2081 }
2082 break;
2083 }
2084 case QOMX_IndexConfigVideoLTRPeriod:
2085 {
2086 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE);
2087 QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE*)configData;
2088 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRPeriod)) {
2089 DEBUG_PRINT_ERROR("ERROR: Setting LTR period failed");
2090 return OMX_ErrorUnsupportedSetting;
2091 }
2092 memcpy(&m_sConfigLTRPeriod, pParam, sizeof(m_sConfigLTRPeriod));
2093 break;
2094 }
2095
2096 case OMX_IndexConfigVideoVp8ReferenceFrame:
2097 {
2098 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_VP8REFERENCEFRAMETYPE);
2099 OMX_VIDEO_VP8REFERENCEFRAMETYPE* pParam = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*) configData;
2100 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE) OMX_IndexConfigVideoVp8ReferenceFrame)) {
2101 DEBUG_PRINT_ERROR("ERROR: Setting VP8 reference frame");
2102 return OMX_ErrorUnsupportedSetting;
2103 }
2104 memcpy(&m_sConfigVp8ReferenceFrame, pParam, sizeof(m_sConfigVp8ReferenceFrame));
2105 break;
2106 }
2107
2108 case QOMX_IndexConfigVideoLTRUse:
2109 {
2110 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRUSE_TYPE);
2111 QOMX_VIDEO_CONFIG_LTRUSE_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRUSE_TYPE*)configData;
2112 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRUse)) {
2113 DEBUG_PRINT_ERROR("ERROR: Setting LTR use failed");
2114 return OMX_ErrorUnsupportedSetting;
2115 }
2116 memcpy(&m_sConfigLTRUse, pParam, sizeof(m_sConfigLTRUse));
2117 break;
2118 }
2119 case QOMX_IndexConfigVideoLTRMark:
2120 {
2121 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRMARK_TYPE);
2122 QOMX_VIDEO_CONFIG_LTRMARK_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRMARK_TYPE*)configData;
2123 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRMark)) {
2124 DEBUG_PRINT_ERROR("ERROR: Setting LTR mark failed");
2125 return OMX_ErrorUnsupportedSetting;
2126 }
2127 break;
2128 }
2129 case OMX_IndexConfigVideoAVCIntraPeriod:
2130 {
2131 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_AVCINTRAPERIOD);
2132 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pParam = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD*) configData;
2133 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigVideoAVCIntraPeriod");
2134 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigVideoAVCIntraPeriod)) {
2135 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoAVCIntraPeriod failed");
2136 return OMX_ErrorUnsupportedSetting;
2137 }
2138 memcpy(&m_sConfigAVCIDRPeriod, pParam, sizeof(m_sConfigAVCIDRPeriod));
2139 break;
2140 }
2141 case OMX_IndexConfigCommonDeinterlace:
2142 {
2143 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_DEINTERLACE);
2144 OMX_VIDEO_CONFIG_DEINTERLACE *pParam = (OMX_VIDEO_CONFIG_DEINTERLACE*) configData;
2145 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigCommonDeinterlace");
2146 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigCommonDeinterlace)) {
2147 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigCommonDeinterlace failed");
2148 return OMX_ErrorUnsupportedSetting;
2149 }
2150 memcpy(&m_sConfigDeinterlace, pParam, sizeof(m_sConfigDeinterlace));
2151 break;
2152 }
2153 case OMX_QcomIndexConfigVideoVencPerfMode:
2154 {
2155 VALIDATE_OMX_PARAM_DATA(configData, QOMX_EXTNINDEX_VIDEO_PERFMODE);
2156 QOMX_EXTNINDEX_VIDEO_PERFMODE* pParam = (QOMX_EXTNINDEX_VIDEO_PERFMODE*)configData;
2157 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode)) {
2158 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigVideoVencPerfMode failed");
2159 return OMX_ErrorUnsupportedSetting;
2160 }
2161 break;
2162 }
2163 case OMX_QcomIndexConfigNumHierPLayers:
2164 {
2165 VALIDATE_OMX_PARAM_DATA(configData, QOMX_EXTNINDEX_VIDEO_HIER_P_LAYERS);
2166 QOMX_EXTNINDEX_VIDEO_HIER_P_LAYERS* pParam =
2167 (QOMX_EXTNINDEX_VIDEO_HIER_P_LAYERS*)configData;
2168 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigNumHierPLayers)) {
2169 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigNumHierPLayers failed");
2170 return OMX_ErrorUnsupportedSetting;
2171 }
2172 memcpy(&m_sHPlayers, pParam, sizeof(m_sHPlayers));
2173 break;
2174 }
2175 case OMX_QcomIndexConfigBaseLayerId:
2176 {
2177 VALIDATE_OMX_PARAM_DATA(configData, OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID);
2178 OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID* pParam =
2179 (OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID*) configData;
2180 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigBaseLayerId)) {
2181 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigBaseLayerId failed");
2182 return OMX_ErrorUnsupportedSetting;
2183 }
2184 memcpy(&m_sBaseLayerID, pParam, sizeof(m_sBaseLayerID));
2185 break;
2186 }
2187 case OMX_QcomIndexConfigQp:
2188 {
2189 VALIDATE_OMX_PARAM_DATA(configData, OMX_SKYPE_VIDEO_CONFIG_QP);
2190 OMX_SKYPE_VIDEO_CONFIG_QP* pParam =
2191 (OMX_SKYPE_VIDEO_CONFIG_QP*) configData;
2192 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigQp)) {
2193 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigQp failed");
2194 return OMX_ErrorUnsupportedSetting;
2195 }
2196 memcpy(&m_sConfigQP, pParam, sizeof(m_sConfigQP));
2197 break;
2198 }
2199 case OMX_IndexConfigPriority:
2200 {
2201 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
2202 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigPriority)) {
2203 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigPriority");
2204 return OMX_ErrorUnsupportedSetting;
2205 }
2206 break;
2207 }
2208 case OMX_IndexConfigOperatingRate:
2209 {
2210 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
2211 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigOperatingRate)) {
2212 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigOperatingRate");
2213 return handle->hw_overload ? OMX_ErrorInsufficientResources :
2214 OMX_ErrorUnsupportedSetting;
2215 }
2216 break;
2217 }
2218 case OMX_QTIIndexConfigVideoRoiInfo:
2219 {
2220 VALIDATE_OMX_PARAM_DATA(configData, OMX_QTI_VIDEO_CONFIG_ROIINFO);
2221 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QTIIndexConfigVideoRoiInfo)) {
2222 DEBUG_PRINT_ERROR("Failed to set OMX_QTIIndexConfigVideoRoiInfo");
2223 return OMX_ErrorUnsupportedSetting;
2224 }
2225 break;
2226 }
2227 case OMX_IndexConfigTimePosition:
2228 {
2229 OMX_TIME_CONFIG_TIMESTAMPTYPE* pParam =
2230 (OMX_TIME_CONFIG_TIMESTAMPTYPE*) configData;
2231 pthread_mutex_lock(×tamp.m_lock);
2232 timestamp.m_TimeStamp = (OMX_U64)pParam->nTimestamp;
2233 DEBUG_PRINT_LOW("Buffer = %p, Timestamp = %llu", timestamp.pending_buffer, (OMX_U64)pParam->nTimestamp);
2234 if (timestamp.is_buffer_pending && (OMX_U64)timestamp.pending_buffer->nTimeStamp == timestamp.m_TimeStamp) {
2235 DEBUG_PRINT_INFO("Queueing back pending buffer %p", timestamp.pending_buffer);
2236 this->post_event((unsigned long)hComp,(unsigned long)timestamp.pending_buffer,m_input_msg_id);
2237 timestamp.pending_buffer = NULL;
2238 timestamp.is_buffer_pending = false;
2239 }
2240 pthread_mutex_unlock(×tamp.m_lock);
2241 break;
2242 }
2243 #ifdef SUPPORT_CONFIG_INTRA_REFRESH
2244 case OMX_IndexConfigAndroidIntraRefresh:
2245 {
2246 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE);
2247 OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE* pParam =
2248 (OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE*) configData;
2249 if (m_state == OMX_StateLoaded
2250 || m_sInPortDef.bEnabled == OMX_FALSE
2251 || m_sOutPortDef.bEnabled == OMX_FALSE) {
2252 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh)) {
2253 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigVideoIntraRefreshType");
2254 return OMX_ErrorUnsupportedSetting;
2255 }
2256 m_sConfigIntraRefresh.nRefreshPeriod = pParam->nRefreshPeriod;
2257 } else {
2258 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigAndroidIntraRefresh supported only at start of session");
2259 return OMX_ErrorUnsupportedSetting;
2260 }
2261 break;
2262 }
2263 #endif
2264 case OMX_QTIIndexConfigVideoBlurResolution:
2265 {
2266 VALIDATE_OMX_PARAM_DATA(configData, OMX_QTI_VIDEO_CONFIG_BLURINFO);
2267 OMX_QTI_VIDEO_CONFIG_BLURINFO* pParam =
2268 (OMX_QTI_VIDEO_CONFIG_BLURINFO*) configData;
2269 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QTIIndexConfigVideoBlurResolution)) {
2270 DEBUG_PRINT_ERROR("Failed to set OMX_QTIIndexConfigVideoBlurResolution");
2271 return OMX_ErrorUnsupportedSetting;
2272 }
2273 memcpy(&m_blurInfo, pParam, sizeof(m_blurInfo));
2274 break;
2275 }
2276 case OMX_QcomIndexConfigH264Transform8x8:
2277 {
2278 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QcomIndexConfigH264Transform8x8)) {
2279 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigH264Transform8x8 failed");
2280 return OMX_ErrorUnsupportedSetting;
2281 }
2282 break;
2283 }
2284 case OMX_QTIIndexConfigDescribeColorAspects:
2285 {
2286 VALIDATE_OMX_PARAM_DATA(configData, DescribeColorAspectsParams);
2287 DescribeColorAspectsParams *params = (DescribeColorAspectsParams *)configData;
2288 print_debug_color_aspects(&(params->sAspects), "set_config");
2289
2290 // WA: Android client does not set the correct color-aspects (from dataspace).
2291 // Such a dataspace change is detected and set while in executing. This leads to
2292 // a race condition where client is trying to set (wrong) color and component trying
2293 // to set (right) color from ETB.
2294 // Hence ignore this config in Executing state till the framework starts setting right color.
2295 if (m_state == OMX_StateExecuting) {
2296 DEBUG_PRINT_HIGH("Ignoring ColorSpace setting in Executing state");
2297 return OMX_ErrorUnsupportedSetting;
2298 }
2299
2300 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QTIIndexConfigDescribeColorAspects)) {
2301 DEBUG_PRINT_ERROR("Failed to set OMX_QTIIndexConfigDescribeColorAspects");
2302 return OMX_ErrorUnsupportedSetting;
2303 }
2304 memcpy(&m_sConfigColorAspects, configData, sizeof(m_sConfigColorAspects));
2305 break;
2306 }
2307 case OMX_IndexConfigAndroidVideoTemporalLayering:
2308 {
2309 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE);
2310 DEBUG_PRINT_ERROR("Setting/modifying Temporal layers at run-time is not supported !");
2311 return OMX_ErrorUnsupportedSetting;
2312 }
2313 case OMX_QcomIndexConfigPerfLevel:
2314 {
2315 VALIDATE_OMX_PARAM_DATA(configData, OMX_QCOM_VIDEO_CONFIG_PERF_LEVEL);
2316 if (!handle->venc_set_config(configData,
2317 (OMX_INDEXTYPE)OMX_QcomIndexConfigPerfLevel)) {
2318 DEBUG_PRINT_ERROR("Failed to set perf level");
2319 return OMX_ErrorUnsupportedSetting;
2320 }
2321 }
2322 case OMX_IndexConfigAndroidVendorExtension:
2323 {
2324 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE);
2325
2326 OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext =
2327 reinterpret_cast<OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *>(configData);
2328 VALIDATE_OMX_VENDOR_EXTENSION_PARAM_DATA(ext);
2329
2330 return set_vendor_extension_config(ext);
2331 }
2332
2333 default:
2334 DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex);
2335 break;
2336 }
2337
2338 return OMX_ErrorNone;
2339 }
2340
2341 /* ======================================================================
2342 FUNCTION
2343 omx_venc::ComponentDeInit
2344
2345 DESCRIPTION
2346 Destroys the component and release memory allocated to the heap.
2347
2348 PARAMETERS
2349 <TBD>.
2350
2351 RETURN VALUE
2352 OMX Error None if everything successful.
2353
2354 ========================================================================== */
component_deinit(OMX_IN OMX_HANDLETYPE hComp)2355 OMX_ERRORTYPE omx_venc::component_deinit(OMX_IN OMX_HANDLETYPE hComp)
2356 {
2357 (void) hComp;
2358 OMX_U32 i = 0;
2359 DEBUG_PRINT_HIGH("omx_venc(): Inside component_deinit()");
2360 if (OMX_StateLoaded != m_state) {
2361 DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d",\
2362 m_state);
2363 }
2364
2365 auto_lock l(m_buf_lock);
2366 if (m_out_mem_ptr) {
2367 DEBUG_PRINT_LOW("Freeing the Output Memory");
2368 for (i=0; i< m_sOutPortDef.nBufferCountActual; i++ ) {
2369 if (BITMASK_PRESENT(&m_out_bm_count, i)) {
2370 BITMASK_CLEAR(&m_out_bm_count, i);
2371 if (BITMASK_PRESENT(&m_client_out_bm_count, i))
2372 BITMASK_CLEAR(&m_client_out_bm_count, i);
2373 free_output_buffer (&m_out_mem_ptr[i]);
2374 }
2375
2376 if (release_output_done()) {
2377 break;
2378 }
2379 }
2380 free(m_out_mem_ptr);
2381 m_out_mem_ptr = NULL;
2382 }
2383
2384 /*Check if the input buffers have to be cleaned up*/
2385 if (m_inp_mem_ptr
2386 #ifdef _ANDROID_ICS_
2387 && !meta_mode_enable
2388 #endif
2389 ) {
2390 DEBUG_PRINT_LOW("Freeing the Input Memory");
2391 for (i=0; i<m_sInPortDef.nBufferCountActual; i++ ) {
2392 if (BITMASK_PRESENT(&m_inp_bm_count, i)) {
2393 BITMASK_CLEAR(&m_inp_bm_count, i);
2394 if (BITMASK_PRESENT(&m_client_in_bm_count, i))
2395 BITMASK_CLEAR(&m_client_in_bm_count, i);
2396 free_input_buffer (&m_inp_mem_ptr[i]);
2397 }
2398
2399 if (release_input_done()) {
2400 break;
2401 }
2402 }
2403
2404
2405 free(m_inp_mem_ptr);
2406 m_inp_mem_ptr = NULL;
2407 }
2408
2409 // Reset counters in mesg queues
2410 m_ftb_q.m_size=0;
2411 m_cmd_q.m_size=0;
2412 m_etb_q.m_size=0;
2413 m_ftb_q.m_read = m_ftb_q.m_write =0;
2414 m_cmd_q.m_read = m_cmd_q.m_write =0;
2415 m_etb_q.m_read = m_etb_q.m_write =0;
2416
2417 DEBUG_PRINT_HIGH("Calling venc_close()");
2418 if (handle) {
2419 handle->venc_close();
2420 DEBUG_PRINT_HIGH("Deleting HANDLE[%p]", handle);
2421 delete (handle);
2422 handle = NULL;
2423 }
2424 DEBUG_PRINT_INFO("Component Deinit");
2425 return OMX_ErrorNone;
2426 }
2427
2428
dev_stop(void)2429 OMX_U32 omx_venc::dev_stop( void)
2430 {
2431 return handle->venc_stop();
2432 }
2433
2434
dev_pause(void)2435 OMX_U32 omx_venc::dev_pause(void)
2436 {
2437 return handle->venc_pause();
2438 }
2439
dev_start(void)2440 OMX_U32 omx_venc::dev_start(void)
2441 {
2442 return handle->venc_start();
2443 }
2444
dev_flush(unsigned port)2445 OMX_U32 omx_venc::dev_flush(unsigned port)
2446 {
2447 return handle->venc_flush(port);
2448 }
dev_resume(void)2449 OMX_U32 omx_venc::dev_resume(void)
2450 {
2451 return handle->venc_resume();
2452 }
2453
dev_start_done(void)2454 OMX_U32 omx_venc::dev_start_done(void)
2455 {
2456 return handle->venc_start_done();
2457 }
2458
dev_set_message_thread_id(pthread_t tid)2459 OMX_U32 omx_venc::dev_set_message_thread_id(pthread_t tid)
2460 {
2461 return handle->venc_set_message_thread_id(tid);
2462 }
2463
dev_use_buf(void * buf_addr,unsigned port,unsigned index)2464 bool omx_venc::dev_use_buf(void *buf_addr,unsigned port,unsigned index)
2465 {
2466 return handle->venc_use_buf(buf_addr,port,index);
2467 }
2468
dev_buffer_ready_to_queue(OMX_BUFFERHEADERTYPE * buffer)2469 bool omx_venc::dev_buffer_ready_to_queue(OMX_BUFFERHEADERTYPE *buffer)
2470 {
2471 bool bRet = true;
2472
2473 pthread_mutex_lock(×tamp.m_lock);
2474
2475 if ((!m_slowLatencyMode.bLowLatencyMode) || ((OMX_U64)buffer->nTimeStamp == (OMX_U64)timestamp.m_TimeStamp)) {
2476 DEBUG_PRINT_LOW("ETB is ready to be queued");
2477 } else {
2478 DEBUG_PRINT_INFO("ETB is defeffed due to timeStamp mismatch");
2479 timestamp.is_buffer_pending = true;
2480 timestamp.pending_buffer = buffer;
2481 bRet = false;
2482 }
2483 pthread_mutex_unlock(×tamp.m_lock);
2484 return bRet;
2485 }
2486
dev_free_buf(void * buf_addr,unsigned port)2487 bool omx_venc::dev_free_buf(void *buf_addr,unsigned port)
2488 {
2489 return handle->venc_free_buf(buf_addr,port);
2490 }
2491
dev_empty_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2492 bool omx_venc::dev_empty_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2493 {
2494 bool bret = false;
2495 bret = handle->venc_empty_buf(buffer, pmem_data_buf,index,fd);
2496 hw_overload = handle->hw_overload;
2497 return bret;
2498 }
2499
dev_fill_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2500 bool omx_venc::dev_fill_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2501 {
2502 return handle->venc_fill_buf(buffer, pmem_data_buf,index,fd);
2503 }
2504
dev_get_seq_hdr(void * buffer,unsigned size,unsigned * hdrlen)2505 bool omx_venc::dev_get_seq_hdr(void *buffer, unsigned size, unsigned *hdrlen)
2506 {
2507 return handle->venc_get_seq_hdr(buffer, size, hdrlen);
2508 }
2509
dev_get_capability_ltrcount(OMX_U32 * min,OMX_U32 * max,OMX_U32 * step_size)2510 bool omx_venc::dev_get_capability_ltrcount(OMX_U32 *min, OMX_U32 *max, OMX_U32 *step_size)
2511 {
2512 #ifdef _MSM8974_
2513 (void) min;
2514 (void) max;
2515 (void) step_size;
2516 DEBUG_PRINT_ERROR("Get Capability LTR Count is not supported");
2517 return false;
2518 #else
2519 return handle->venc_get_capability_ltrcount(min, max, step_size);
2520 #endif
2521 }
2522
dev_get_performance_level(OMX_U32 * perflevel)2523 bool omx_venc::dev_get_performance_level(OMX_U32 *perflevel)
2524 {
2525 #ifdef _MSM8974_
2526 return handle->venc_get_performance_level(perflevel);
2527 #else
2528 DEBUG_PRINT_ERROR("Get performance level is not supported");
2529 return false;
2530 #endif
2531 }
2532
dev_get_vui_timing_info(OMX_U32 * enabled)2533 bool omx_venc::dev_get_vui_timing_info(OMX_U32 *enabled)
2534 {
2535 #ifdef _MSM8974_
2536 return handle->venc_get_vui_timing_info(enabled);
2537 #else
2538 DEBUG_PRINT_ERROR("Get vui timing information is not supported");
2539 return false;
2540 #endif
2541 }
2542
dev_get_vqzip_sei_info(OMX_U32 * enabled)2543 bool omx_venc::dev_get_vqzip_sei_info(OMX_U32 *enabled)
2544 {
2545 return handle->venc_get_vqzip_sei_info(enabled);
2546 }
2547
dev_get_peak_bitrate(OMX_U32 * peakbitrate)2548 bool omx_venc::dev_get_peak_bitrate(OMX_U32 *peakbitrate)
2549 {
2550 #ifdef _MSM8974_
2551 return handle->venc_get_peak_bitrate(peakbitrate);
2552 #else
2553 DEBUG_PRINT_ERROR("Get peak bitrate is not supported");
2554 return false;
2555 #endif
2556 }
2557
dev_get_batch_size(OMX_U32 * size)2558 bool omx_venc::dev_get_batch_size(OMX_U32 *size)
2559 {
2560 #ifdef _MSM8974_
2561 return handle->venc_get_batch_size(size);
2562 #else
2563 DEBUG_PRINT_ERROR("Get batch size is not supported");
2564 return false;
2565 #endif
2566 }
2567
dev_get_temporal_layer_caps(OMX_U32 * nMaxLayers,OMX_U32 * nMaxBLayers)2568 bool omx_venc::dev_get_temporal_layer_caps(OMX_U32 *nMaxLayers,
2569 OMX_U32 *nMaxBLayers) {
2570 return handle->venc_get_temporal_layer_caps(nMaxLayers, nMaxBLayers);
2571 }
2572
dev_get_pq_status(OMX_BOOL * pq_status)2573 bool omx_venc::dev_get_pq_status(OMX_BOOL *pq_status) {
2574 return handle->venc_get_pq_status(pq_status);
2575 }
2576
dev_loaded_start()2577 bool omx_venc::dev_loaded_start()
2578 {
2579 return handle->venc_loaded_start();
2580 }
2581
dev_loaded_stop()2582 bool omx_venc::dev_loaded_stop()
2583 {
2584 return handle->venc_loaded_stop();
2585 }
2586
dev_loaded_start_done()2587 bool omx_venc::dev_loaded_start_done()
2588 {
2589 return handle->venc_loaded_start_done();
2590 }
2591
dev_loaded_stop_done()2592 bool omx_venc::dev_loaded_stop_done()
2593 {
2594 return handle->venc_loaded_stop_done();
2595 }
2596
dev_get_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2597 bool omx_venc::dev_get_buf_req(OMX_U32 *min_buff_count,
2598 OMX_U32 *actual_buff_count,
2599 OMX_U32 *buff_size,
2600 OMX_U32 port)
2601 {
2602 return handle->venc_get_buf_req(min_buff_count,
2603 actual_buff_count,
2604 buff_size,
2605 port);
2606
2607 }
2608
dev_set_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2609 bool omx_venc::dev_set_buf_req(OMX_U32 *min_buff_count,
2610 OMX_U32 *actual_buff_count,
2611 OMX_U32 *buff_size,
2612 OMX_U32 port)
2613 {
2614 return handle->venc_set_buf_req(min_buff_count,
2615 actual_buff_count,
2616 buff_size,
2617 port);
2618
2619 }
2620
dev_is_video_session_supported(OMX_U32 width,OMX_U32 height)2621 bool omx_venc::dev_is_video_session_supported(OMX_U32 width, OMX_U32 height)
2622 {
2623 #ifdef _MSM8974_
2624 return handle->venc_is_video_session_supported(width,height);
2625 #else
2626 DEBUG_PRINT_LOW("Check against video capability not supported");
2627 return true;
2628 #endif
2629 }
2630
dev_handle_output_extradata(void * buffer,int index)2631 int omx_venc::dev_handle_output_extradata(void *buffer, int index)
2632 {
2633 return handle->handle_output_extradata(buffer, index);
2634 }
2635
dev_set_format(int color)2636 int omx_venc::dev_set_format(int color)
2637 {
2638 return handle->venc_set_format(color);
2639 }
2640
async_message_process(void * context,void * message)2641 int omx_venc::async_message_process (void *context, void* message)
2642 {
2643 omx_video* omx = NULL;
2644 struct venc_msg *m_sVenc_msg = NULL;
2645 OMX_BUFFERHEADERTYPE* omxhdr = NULL;
2646 struct venc_buffer *temp_buff = NULL;
2647 native_handle_t *nh = NULL;
2648
2649 if (context == NULL || message == NULL) {
2650 DEBUG_PRINT_ERROR("ERROR: omx_venc::async_message_process invalid i/p params");
2651 return -1;
2652 }
2653 m_sVenc_msg = (struct venc_msg *)message;
2654
2655 omx = reinterpret_cast<omx_video*>(context);
2656
2657 if (m_sVenc_msg->statuscode != VEN_S_SUCCESS) {
2658 DEBUG_PRINT_ERROR("ERROR: async_msg_process() - Error statuscode = %lu",
2659 m_sVenc_msg->statuscode);
2660 if(m_sVenc_msg->msgcode == VEN_MSG_HW_OVERLOAD) {
2661 omx->post_event (0, m_sVenc_msg->statuscode,\
2662 OMX_COMPONENT_GENERATE_HARDWARE_OVERLOAD);
2663 } else {
2664 omx->post_event (0, m_sVenc_msg->statuscode,\
2665 OMX_COMPONENT_GENERATE_HARDWARE_ERROR);
2666 }
2667 }
2668
2669 DEBUG_PRINT_LOW("omx_venc::async_message_process- msgcode = %lu",
2670 m_sVenc_msg->msgcode);
2671 switch (m_sVenc_msg->msgcode) {
2672 case VEN_MSG_START:
2673 omx->post_event (0,m_sVenc_msg->statuscode,\
2674 OMX_COMPONENT_GENERATE_START_DONE);
2675 break;
2676 case VEN_MSG_STOP:
2677 omx->post_event (0,m_sVenc_msg->statuscode,\
2678 OMX_COMPONENT_GENERATE_STOP_DONE);
2679 break;
2680 case VEN_MSG_RESUME:
2681 omx->post_event (0,m_sVenc_msg->statuscode,\
2682 OMX_COMPONENT_GENERATE_RESUME_DONE);
2683 break;
2684 case VEN_MSG_PAUSE:
2685 omx->post_event (0,m_sVenc_msg->statuscode,\
2686 OMX_COMPONENT_GENERATE_PAUSE_DONE);
2687 break;
2688 case VEN_MSG_FLUSH_INPUT_DONE:
2689
2690 omx->post_event (0,m_sVenc_msg->statuscode,\
2691 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH);
2692 break;
2693 case VEN_MSG_FLUSH_OUPUT_DONE:
2694 omx->post_event (0,m_sVenc_msg->statuscode,\
2695 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH);
2696 break;
2697 case VEN_MSG_INPUT_BUFFER_DONE:
2698 omxhdr = (OMX_BUFFERHEADERTYPE* )\
2699 m_sVenc_msg->buf.clientdata;
2700
2701 if (omxhdr == NULL ||
2702 (((OMX_U32)(omxhdr - omx->m_inp_mem_ptr) > omx->m_sInPortDef.nBufferCountActual) &&
2703 ((OMX_U32)(omxhdr - omx->meta_buffer_hdr) > omx->m_sInPortDef.nBufferCountActual))) {
2704 omxhdr = NULL;
2705 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2706 }
2707
2708 #ifdef _ANDROID_ICS_
2709 omx->omx_release_meta_buffer(omxhdr);
2710 #endif
2711 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2712 OMX_COMPONENT_GENERATE_EBD);
2713 break;
2714 case VEN_MSG_OUTPUT_BUFFER_DONE:
2715 {
2716 omxhdr = (OMX_BUFFERHEADERTYPE*)m_sVenc_msg->buf.clientdata;
2717 OMX_U32 bufIndex = (OMX_U32)(omxhdr - omx->m_out_mem_ptr);
2718
2719 if ( (omxhdr != NULL) &&
2720 (bufIndex < omx->m_sOutPortDef.nBufferCountActual)) {
2721 auto_lock l(omx->m_buf_lock);
2722 if (BITMASK_ABSENT(&(omx->m_out_bm_count), bufIndex)) {
2723 DEBUG_PRINT_ERROR("Recieved FBD for buffer that is already freed !");
2724 break;
2725 }
2726 if (!omx->is_secure_session() && (m_sVenc_msg->buf.len <= omxhdr->nAllocLen)) {
2727 omxhdr->nFilledLen = m_sVenc_msg->buf.len;
2728 omxhdr->nOffset = m_sVenc_msg->buf.offset;
2729 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2730 DEBUG_PRINT_LOW("o/p TS = %u", (unsigned int)m_sVenc_msg->buf.timestamp);
2731 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2732
2733 /*Use buffer case*/
2734 if (BITMASK_PRESENT(&(omx->m_client_out_bm_count), bufIndex) &&
2735 omx->output_use_buffer && !omx->m_use_output_pmem && !omx->is_secure_session()) {
2736 DEBUG_PRINT_LOW("memcpy() for o/p Heap UseBuffer");
2737 memcpy(omxhdr->pBuffer,
2738 (m_sVenc_msg->buf.ptrbuffer),
2739 m_sVenc_msg->buf.len);
2740 }
2741 } else if (omx->is_secure_session()) {
2742 if (omx->allocate_native_handle) {
2743 native_handle_t *nh = (native_handle_t *)(omxhdr->pBuffer);
2744 nh->data[1] = m_sVenc_msg->buf.offset;
2745 nh->data[2] = m_sVenc_msg->buf.len;
2746 omxhdr->nFilledLen = m_sVenc_msg->buf.len;
2747 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2748 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2749 } else {
2750 output_metabuffer *meta_buf = (output_metabuffer *)(omxhdr->pBuffer);
2751 native_handle_t *nh = meta_buf->nh;
2752 nh->data[1] = m_sVenc_msg->buf.offset;
2753 nh->data[2] = m_sVenc_msg->buf.len;
2754 omxhdr->nFilledLen = sizeof(output_metabuffer);
2755 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2756 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2757 }
2758 } else {
2759 omxhdr->nFilledLen = 0;
2760 }
2761
2762 } else {
2763 omxhdr = NULL;
2764 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2765 }
2766 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2767 OMX_COMPONENT_GENERATE_FBD);
2768 break;
2769 }
2770 case VEN_MSG_NEED_OUTPUT_BUFFER:
2771 //TBD what action needs to be done here??
2772 break;
2773 #ifndef _MSM8974_
2774 case VEN_MSG_LTRUSE_FAILED:
2775 DEBUG_PRINT_ERROR("LTRUSE Failed!");
2776 omx->post_event (NULL,m_sVenc_msg->statuscode,
2777 OMX_COMPONENT_GENERATE_LTRUSE_FAILED);
2778 break;
2779 #endif
2780 default:
2781 DEBUG_PRINT_HIGH("Unknown msg received : %lu", m_sVenc_msg->msgcode);
2782 break;
2783 }
2784 return 0;
2785 }
2786
dev_color_align(OMX_BUFFERHEADERTYPE * buffer,OMX_U32 width,OMX_U32 height)2787 bool omx_venc::dev_color_align(OMX_BUFFERHEADERTYPE *buffer,
2788 OMX_U32 width, OMX_U32 height)
2789 {
2790 if(secure_session) {
2791 DEBUG_PRINT_ERROR("Cannot align colors in secure session.");
2792 return OMX_FALSE;
2793 }
2794 return handle->venc_color_align(buffer, width,height);
2795 }
2796
is_secure_session()2797 bool omx_venc::is_secure_session()
2798 {
2799 return secure_session;
2800 }
2801
dev_get_output_log_flag()2802 bool omx_venc::dev_get_output_log_flag()
2803 {
2804 return handle->venc_get_output_log_flag();
2805 }
2806
dev_output_log_buffers(const char * buffer,int bufferlen)2807 int omx_venc::dev_output_log_buffers(const char *buffer, int bufferlen)
2808 {
2809 return handle->venc_output_log_buffers(buffer, bufferlen);
2810 }
2811
dev_extradata_log_buffers(char * buffer)2812 int omx_venc::dev_extradata_log_buffers(char *buffer)
2813 {
2814 return handle->venc_extradata_log_buffers(buffer);
2815 }
2816