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