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