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