/*-------------------------------------------------------------------------- Copyright (c) 2010 - 2020, The Linux Foundation. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of The Linux Foundation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------*/ /*============================================================================ O p e n M A X w r a p p e r s O p e n M A X C o r e This module contains the implementation of the OpenMAX core & component. *//*========================================================================*/ ////////////////////////////////////////////////////////////////////////////// // Include Files ////////////////////////////////////////////////////////////////////////////// #include "omx_vdec.h" #define BUFFER_LOG_LOC "/data/vendor/media" #ifdef _ANDROID_ extern "C" { #include } #endif//_ANDROID_ using namespace android; /* ====================================================================== FUNCTION omx_vdec::GetParameter DESCRIPTION OMX Get Parameter method implementation PARAMETERS . RETURN VALUE Error None if successful. ========================================================================== */ OMX_ERRORTYPE omx_vdec::get_parameter(OMX_IN OMX_HANDLETYPE hComp, OMX_IN OMX_INDEXTYPE paramIndex, OMX_INOUT OMX_PTR paramData) { (void) hComp; OMX_ERRORTYPE eRet = OMX_ErrorNone; DEBUG_PRINT_LOW("get_parameter:"); if (m_state == OMX_StateInvalid) { DEBUG_PRINT_ERROR("Get Param in Invalid State"); return OMX_ErrorInvalidState; } if (paramData == NULL) { DEBUG_PRINT_LOW("Get Param in Invalid paramData"); return OMX_ErrorBadParameter; } switch ((unsigned long)paramIndex) { case OMX_IndexParamPortDefinition: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_PORTDEFINITIONTYPE); OMX_PARAM_PORTDEFINITIONTYPE *portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamPortDefinition"); OMX_COLOR_FORMATTYPE drv_color_format; bool status = false; if (!client_buffers.is_color_conversion_enabled()) { status = client_buffers.get_color_format(drv_color_format); } fix_drv_output_format(); if (status) { if (!client_buffers.is_color_conversion_enabled()) { client_buffers.set_client_buffers_disabled(true); client_buffers.set_color_format(drv_color_format); } } eRet = update_portdef(portDefn); if (eRet == OMX_ErrorNone) m_port_def = *portDefn; break; } case OMX_IndexParamVideoInit: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PORT_PARAM_TYPE); OMX_PORT_PARAM_TYPE *portParamType = (OMX_PORT_PARAM_TYPE *) paramData; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoInit"); portParamType->nVersion.nVersion = OMX_SPEC_VERSION; portParamType->nSize = sizeof(OMX_PORT_PARAM_TYPE); portParamType->nPorts = 2; portParamType->nStartPortNumber = 0; break; } case OMX_IndexParamVideoPortFormat: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PORTFORMATTYPE); OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoPortFormat"); portFmt->nVersion.nVersion = OMX_SPEC_VERSION; portFmt->nSize = sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE); if (0 == portFmt->nPortIndex) { if (0 == portFmt->nIndex) { portFmt->eColorFormat = OMX_COLOR_FormatUnused; portFmt->eCompressionFormat = eCompressionFormat; } else { DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoPortFormat:"\ " NoMore compression formats"); eRet = OMX_ErrorNoMore; } } else if (1 == portFmt->nPortIndex) { portFmt->eCompressionFormat = OMX_VIDEO_CodingUnused; // Distinguish non-surface mode from normal playback use-case based on // usage hinted via "OMX.google.android.index.useAndroidNativeBuffer2" // For non-android, use the default list // Also use default format-list if FLEXIBLE YUV is supported, // as the client negotiates the standard color-format if it needs to bool useNonSurfaceMode = false; #if defined(_ANDROID_) && !defined(FLEXYUV_SUPPORTED) && !defined(USE_GBM) useNonSurfaceMode = (m_enable_android_native_buffers == OMX_FALSE); #endif portFmt->eColorFormat = useNonSurfaceMode ? getPreferredColorFormatNonSurfaceMode(portFmt->nIndex) : getPreferredColorFormatDefaultMode(portFmt->nIndex); if (portFmt->eColorFormat == OMX_COLOR_FormatMax ) { eRet = OMX_ErrorNoMore; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoPortFormat:"\ " NoMore Color formats"); } DEBUG_PRINT_HIGH("returning color-format: 0x%x", portFmt->eColorFormat); } else { DEBUG_PRINT_ERROR("get_parameter: Bad port index %d", (int)portFmt->nPortIndex); eRet = OMX_ErrorBadPortIndex; } break; } /*Component should support this port definition*/ case OMX_IndexParamAudioInit: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PORT_PARAM_TYPE); OMX_PORT_PARAM_TYPE *audioPortParamType = (OMX_PORT_PARAM_TYPE *) paramData; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamAudioInit"); audioPortParamType->nVersion.nVersion = OMX_SPEC_VERSION; audioPortParamType->nSize = sizeof(OMX_PORT_PARAM_TYPE); audioPortParamType->nPorts = 0; audioPortParamType->nStartPortNumber = 0; break; } /*Component should support this port definition*/ case OMX_IndexParamImageInit: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PORT_PARAM_TYPE); OMX_PORT_PARAM_TYPE *imagePortParamType = (OMX_PORT_PARAM_TYPE *) paramData; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamImageInit"); imagePortParamType->nVersion.nVersion = OMX_SPEC_VERSION; imagePortParamType->nSize = sizeof(OMX_PORT_PARAM_TYPE); imagePortParamType->nPorts = 0; imagePortParamType->nStartPortNumber = 0; break; } /*Component should support this port definition*/ case OMX_IndexParamOtherInit: { DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamOtherInit %08x", paramIndex); eRet =OMX_ErrorUnsupportedIndex; break; } case OMX_IndexParamStandardComponentRole: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_COMPONENTROLETYPE); OMX_PARAM_COMPONENTROLETYPE *comp_role; comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData; comp_role->nVersion.nVersion = OMX_SPEC_VERSION; comp_role->nSize = sizeof(*comp_role); DEBUG_PRINT_LOW("Getparameter: OMX_IndexParamStandardComponentRole %d", paramIndex); strlcpy((char*)comp_role->cRole,(const char*)m_cRole, OMX_MAX_STRINGNAME_SIZE); break; } /* Added for parameter test */ case OMX_IndexParamPriorityMgmt: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PRIORITYMGMTTYPE); OMX_PRIORITYMGMTTYPE *priorityMgmType = (OMX_PRIORITYMGMTTYPE *) paramData; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamPriorityMgmt"); priorityMgmType->nVersion.nVersion = OMX_SPEC_VERSION; priorityMgmType->nSize = sizeof(OMX_PRIORITYMGMTTYPE); break; } /* Added for parameter test */ case OMX_IndexParamCompBufferSupplier: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_BUFFERSUPPLIERTYPE); OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData; DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamCompBufferSupplier"); bufferSupplierType->nSize = sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE); bufferSupplierType->nVersion.nVersion = OMX_SPEC_VERSION; if (0 == bufferSupplierType->nPortIndex) bufferSupplierType->nPortIndex = OMX_BufferSupplyUnspecified; else if (1 == bufferSupplierType->nPortIndex) bufferSupplierType->nPortIndex = OMX_BufferSupplyUnspecified; else eRet = OMX_ErrorBadPortIndex; break; } case OMX_IndexParamVideoAvc: { DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoAvc %08x", paramIndex); break; } case (OMX_INDEXTYPE)QOMX_IndexParamVideoMvc: { DEBUG_PRINT_LOW("get_parameter: QOMX_IndexParamVideoMvc %08x", paramIndex); break; } case OMX_IndexParamVideoMpeg2: { DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoMpeg2 %08x", paramIndex); break; } case OMX_IndexParamVideoProfileLevelQuerySupported: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PROFILELEVELTYPE); DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported %08x", paramIndex); OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevelType = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)paramData; eRet = get_supported_profile_level(profileLevelType); break; } #if defined (_ANDROID_HONEYCOMB_) || defined (_ANDROID_ICS_) case OMX_GoogleAndroidIndexGetAndroidNativeBufferUsage: { VALIDATE_OMX_PARAM_DATA(paramData, GetAndroidNativeBufferUsageParams); DEBUG_PRINT_LOW("get_parameter: OMX_GoogleAndroidIndexGetAndroidNativeBufferUsage"); GetAndroidNativeBufferUsageParams* nativeBuffersUsage = (GetAndroidNativeBufferUsageParams *) paramData; if (nativeBuffersUsage->nPortIndex == OMX_CORE_OUTPUT_PORT_INDEX) { if (secure_mode) { nativeBuffersUsage->nUsage = (GRALLOC_USAGE_PRIVATE_MM_HEAP | GRALLOC_USAGE_PROTECTED | GRALLOC_USAGE_PRIVATE_UNCACHED); } else { nativeBuffersUsage->nUsage = GRALLOC_USAGE_PRIVATE_UNCACHED; } } else { DEBUG_PRINT_HIGH("get_parameter: OMX_GoogleAndroidIndexGetAndroidNativeBufferUsage failed!"); eRet = OMX_ErrorBadParameter; } } break; #endif #ifdef FLEXYUV_SUPPORTED case OMX_QcomIndexFlexibleYUVDescription: { DEBUG_PRINT_LOW("get_parameter: describeColorFormat"); VALIDATE_OMX_PARAM_DATA(paramData, DescribeColorFormatParams); eRet = describeColorFormat(paramData); if (eRet == OMX_ErrorUnsupportedSetting) { DEBUG_PRINT_LOW("The standard OMX linear formats are understood by client. Please ignore this Unsupported Setting (0x80001019)."); } break; } #endif case OMX_IndexParamVideoProfileLevelCurrent: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PROFILELEVELTYPE); OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData; struct v4l2_control profile_control, level_control; switch (drv_ctx.decoder_format) { case VDEC_CODECTYPE_H264: profile_control.id = V4L2_CID_MPEG_VIDEO_H264_PROFILE; level_control.id = V4L2_CID_MPEG_VIDEO_H264_LEVEL; break; default: DEBUG_PRINT_ERROR("get_param of OMX_IndexParamVideoProfileLevelCurrent only available for H264"); eRet = OMX_ErrorNotImplemented; break; } if (!eRet && !ioctl(drv_ctx.video_driver_fd, VIDIOC_G_CTRL, &profile_control)) { switch ((enum v4l2_mpeg_video_h264_profile)profile_control.value) { case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE: pParam->eProfile = OMX_VIDEO_AVCProfileBaseline; break; case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE: pParam->eProfile = OMX_VIDEO_AVCProfileConstrainedBaseline; break; case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH: pParam->eProfile = OMX_VIDEO_AVCProfileConstrainedHigh; break; case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN: pParam->eProfile = OMX_VIDEO_AVCProfileMain; break; case V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED: pParam->eProfile = OMX_VIDEO_AVCProfileExtended; break; case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH: pParam->eProfile = OMX_VIDEO_AVCProfileHigh; break; case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10: pParam->eProfile = OMX_VIDEO_AVCProfileHigh10; break; case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422: pParam->eProfile = OMX_VIDEO_AVCProfileHigh422; break; case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE: case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10_INTRA: case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422_INTRA: case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_INTRA: case V4L2_MPEG_VIDEO_H264_PROFILE_CAVLC_444_INTRA: case V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINE: case V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH: case V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH_INTRA: case V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH: case V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH: eRet = OMX_ErrorUnsupportedIndex; break; } } else { eRet = OMX_ErrorUnsupportedIndex; } if (!eRet && !ioctl(drv_ctx.video_driver_fd, VIDIOC_G_CTRL, &level_control)) { switch ((enum v4l2_mpeg_video_h264_level)level_control.value) { case V4L2_MPEG_VIDEO_H264_LEVEL_1_0: pParam->eLevel = OMX_VIDEO_AVCLevel1; break; case V4L2_MPEG_VIDEO_H264_LEVEL_1B: pParam->eLevel = OMX_VIDEO_AVCLevel1b; break; case V4L2_MPEG_VIDEO_H264_LEVEL_1_1: pParam->eLevel = OMX_VIDEO_AVCLevel11; break; case V4L2_MPEG_VIDEO_H264_LEVEL_1_2: pParam->eLevel = OMX_VIDEO_AVCLevel12; break; case V4L2_MPEG_VIDEO_H264_LEVEL_1_3: pParam->eLevel = OMX_VIDEO_AVCLevel13; break; case V4L2_MPEG_VIDEO_H264_LEVEL_2_0: pParam->eLevel = OMX_VIDEO_AVCLevel2; break; case V4L2_MPEG_VIDEO_H264_LEVEL_2_1: pParam->eLevel = OMX_VIDEO_AVCLevel21; break; case V4L2_MPEG_VIDEO_H264_LEVEL_2_2: pParam->eLevel = OMX_VIDEO_AVCLevel22; break; case V4L2_MPEG_VIDEO_H264_LEVEL_3_0: pParam->eLevel = OMX_VIDEO_AVCLevel3; break; case V4L2_MPEG_VIDEO_H264_LEVEL_3_1: pParam->eLevel = OMX_VIDEO_AVCLevel31; break; case V4L2_MPEG_VIDEO_H264_LEVEL_3_2: pParam->eLevel = OMX_VIDEO_AVCLevel32; break; case V4L2_MPEG_VIDEO_H264_LEVEL_4_0: pParam->eLevel = OMX_VIDEO_AVCLevel4; break; case V4L2_MPEG_VIDEO_H264_LEVEL_4_1: pParam->eLevel = OMX_VIDEO_AVCLevel41; break; case V4L2_MPEG_VIDEO_H264_LEVEL_4_2: pParam->eLevel = OMX_VIDEO_AVCLevel42; break; case V4L2_MPEG_VIDEO_H264_LEVEL_5_0: pParam->eLevel = OMX_VIDEO_AVCLevel5; break; case V4L2_MPEG_VIDEO_H264_LEVEL_5_1: pParam->eLevel = OMX_VIDEO_AVCLevel51; break; case V4L2_MPEG_VIDEO_H264_LEVEL_5_2: pParam->eLevel = OMX_VIDEO_AVCLevel52; break; case V4L2_MPEG_VIDEO_H264_LEVEL_6_0: pParam->eLevel = OMX_VIDEO_AVCLevel6; break; case V4L2_MPEG_VIDEO_H264_LEVEL_6_1: pParam->eLevel = OMX_VIDEO_AVCLevel61; break; case V4L2_MPEG_VIDEO_H264_LEVEL_6_2: pParam->eLevel = OMX_VIDEO_AVCLevel62; break; default: eRet = OMX_ErrorUnsupportedIndex; break; } } else { eRet = OMX_ErrorUnsupportedIndex; } break; } case OMX_QTIIndexParamVideoClientExtradata: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTRADATA_ENABLE); DEBUG_PRINT_LOW("get_parameter: OMX_QTIIndexParamVideoClientExtradata"); QOMX_EXTRADATA_ENABLE *pParam = (QOMX_EXTRADATA_ENABLE *)paramData; if (pParam->nPortIndex == OMX_CORE_OUTPUT_EXTRADATA_INDEX) { pParam->bEnable = m_client_extradata ? OMX_TRUE : OMX_FALSE; eRet = OMX_ErrorNone; } else { eRet = OMX_ErrorUnsupportedIndex; } break; } default: { DEBUG_PRINT_ERROR("get_parameter: unknown param %08x", paramIndex); eRet =OMX_ErrorUnsupportedIndex; } } DEBUG_PRINT_LOW("get_parameter returning WxH(%d x %d) SxSH(%d x %d)", drv_ctx.video_resolution.frame_width, drv_ctx.video_resolution.frame_height, drv_ctx.video_resolution.stride, drv_ctx.video_resolution.scan_lines); return eRet; } /* ====================================================================== FUNCTION omx_vdec::Setparameter DESCRIPTION OMX Set Parameter method implementation. PARAMETERS . RETURN VALUE OMX Error None if successful. ========================================================================== */ OMX_ERRORTYPE omx_vdec::set_parameter(OMX_IN OMX_HANDLETYPE hComp, OMX_IN OMX_INDEXTYPE paramIndex, OMX_IN OMX_PTR paramData) { OMX_ERRORTYPE eRet = OMX_ErrorNone; int ret=0; struct v4l2_format fmt; #ifdef _ANDROID_ char property_value[PROPERTY_VALUE_MAX] = {0}; #endif if (m_state == OMX_StateInvalid) { DEBUG_PRINT_ERROR("Set Param in Invalid State"); return OMX_ErrorInvalidState; } if (paramData == NULL) { DEBUG_PRINT_ERROR("Get Param in Invalid paramData"); return OMX_ErrorBadParameter; } if ((m_state != OMX_StateLoaded) && BITMASK_ABSENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING) && (m_out_bEnabled == OMX_TRUE) && BITMASK_ABSENT(&m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING) && (m_inp_bEnabled == OMX_TRUE)) { DEBUG_PRINT_ERROR("Set Param in Invalid State"); return OMX_ErrorIncorrectStateOperation; } switch ((unsigned long)paramIndex) { case OMX_IndexParamPortDefinition: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_PORTDEFINITIONTYPE); OMX_PARAM_PORTDEFINITIONTYPE *portDefn; portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData; //TODO: Check if any allocate buffer/use buffer/useNativeBuffer has //been called. DEBUG_PRINT_LOW( "set_parameter: OMX_IndexParamPortDefinition: dir %d port %d wxh %dx%d count: min %d actual %d size %d", (int)portDefn->eDir, (int)portDefn->nPortIndex, (int)portDefn->format.video.nFrameWidth, (int)portDefn->format.video.nFrameHeight, (int)portDefn->nBufferCountMin, (int)portDefn->nBufferCountActual, (int)portDefn->nBufferSize); if (portDefn->nBufferCountActual > MAX_NUM_INPUT_OUTPUT_BUFFERS) { DEBUG_PRINT_ERROR("ERROR: Buffers requested exceeds max limit %d", portDefn->nBufferCountActual); eRet = OMX_ErrorBadParameter; break; } if (OMX_CORE_OUTPUT_EXTRADATA_INDEX == portDefn->nPortIndex) { if (portDefn->nBufferCountActual < MIN_NUM_INPUT_OUTPUT_EXTRADATA_BUFFERS || portDefn->nBufferSize != m_client_out_extradata_info.getSize()) { DEBUG_PRINT_ERROR("ERROR: Bad parameeters request for extradata limit %d size - %d", portDefn->nBufferCountActual, portDefn->nBufferSize); eRet = OMX_ErrorBadParameter; break; } m_client_out_extradata_info.set_extradata_info(portDefn->nBufferSize, portDefn->nBufferCountActual); break; } if (OMX_DirOutput == portDefn->eDir) { DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPortDefinition OP port"); bool port_format_changed = false; m_display_id = portDefn->format.video.pNativeWindow; unsigned int buffer_size; fix_drv_output_format(); if (portDefn->nBufferCountActual > MAX_NUM_INPUT_OUTPUT_BUFFERS) { DEBUG_PRINT_ERROR("Requested o/p buf count (%u) exceeds limit (%u)", portDefn->nBufferCountActual, MAX_NUM_INPUT_OUTPUT_BUFFERS); eRet = OMX_ErrorBadParameter; } else if (!client_buffers.get_buffer_req(buffer_size)) { DEBUG_PRINT_ERROR("Error in getting buffer requirements"); eRet = OMX_ErrorBadParameter; } else if (!port_format_changed) { // Buffer count can change only when port is unallocated if (m_out_mem_ptr && (portDefn->nBufferCountActual != drv_ctx.op_buf.actualcount || portDefn->nBufferSize != drv_ctx.op_buf.buffer_size)) { DEBUG_PRINT_ERROR("Cannot change o/p buffer count since all buffers are not freed yet !"); eRet = OMX_ErrorInvalidState; break; } // route updating of buffer requirements via c2d proxy. // Based on whether c2d is enabled, requirements will be handed // to the vidc driver appropriately eRet = client_buffers.set_buffer_req(portDefn->nBufferSize, portDefn->nBufferCountActual); if (eRet == OMX_ErrorNone) { m_port_def = *portDefn; } else { DEBUG_PRINT_ERROR("ERROR: OP Requirements(#%d: %u) Requested(#%u: %u)", drv_ctx.op_buf.mincount, (unsigned int)buffer_size, (unsigned int)portDefn->nBufferCountActual, (unsigned int)portDefn->nBufferSize); eRet = OMX_ErrorBadParameter; } } } else if (OMX_DirInput == portDefn->eDir) { DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPortDefinition IP port"); bool port_format_changed = false; if ((portDefn->format.video.xFramerate >> 16) > 0 && (portDefn->format.video.xFramerate >> 16) <= MAX_SUPPORTED_FPS) { // Frame rate only should be set if this is a "known value" or to // activate ts prediction logic (arbitrary mode only) sending input // timestamps with max value (LLONG_MAX). m_fps_received = portDefn->format.video.xFramerate; DEBUG_PRINT_HIGH("set_parameter: frame rate set by omx client : %u", (unsigned int)portDefn->format.video.xFramerate >> 16); Q16ToFraction(portDefn->format.video.xFramerate, drv_ctx.frame_rate.fps_numerator, drv_ctx.frame_rate.fps_denominator); if (!drv_ctx.frame_rate.fps_numerator) { DEBUG_PRINT_ERROR("Numerator is zero setting to 30"); drv_ctx.frame_rate.fps_numerator = 30; } if (drv_ctx.frame_rate.fps_denominator) drv_ctx.frame_rate.fps_numerator = (int) drv_ctx.frame_rate.fps_numerator / drv_ctx.frame_rate.fps_denominator; drv_ctx.frame_rate.fps_denominator = 1; frm_int = drv_ctx.frame_rate.fps_denominator * 1e6 / drv_ctx.frame_rate.fps_numerator; DEBUG_PRINT_LOW("set_parameter: frm_int(%u) fps(%.2f)", (unsigned int)frm_int, drv_ctx.frame_rate.fps_numerator / (float)drv_ctx.frame_rate.fps_denominator); struct v4l2_control control; control.id = V4L2_CID_MPEG_VIDC_VIDEO_FRAME_RATE; control.value = drv_ctx.frame_rate.fps_numerator / drv_ctx.frame_rate.fps_denominator; control.value <<= 16; control.value |= (0x0000FFFF & (drv_ctx.frame_rate.fps_numerator % drv_ctx.frame_rate.fps_denominator)); DEBUG_PRINT_LOW("Calling IOCTL set control for id=%d, val=%d", control.id, control.value); ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_CTRL, &control); if (ret) { DEBUG_PRINT_ERROR("Failed to set control, id %#x, value %d", control.id, control.value); return OMX_ErrorHardware; } } if (drv_ctx.video_resolution.frame_height != portDefn->format.video.nFrameHeight || drv_ctx.video_resolution.frame_width != portDefn->format.video.nFrameWidth) { DEBUG_PRINT_LOW("SetParam IP: WxH(%u x %u)", (unsigned int)portDefn->format.video.nFrameWidth, (unsigned int)portDefn->format.video.nFrameHeight); port_format_changed = true; OMX_U32 frameWidth = portDefn->format.video.nFrameWidth; OMX_U32 frameHeight = portDefn->format.video.nFrameHeight; if (frameHeight != 0x0 && frameWidth != 0x0) { m_extradata_misr.output_crop_rect.nLeft = 0; m_extradata_misr.output_crop_rect.nTop = 0; m_extradata_misr.output_crop_rect.nWidth = frameWidth; m_extradata_misr.output_crop_rect.nHeight = frameHeight; update_resolution(frameWidth, frameHeight, frameWidth, frameHeight); memset(&fmt, 0x0, sizeof(struct v4l2_format)); fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height; fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width; fmt.fmt.pix_mp.pixelformat = output_capability; DEBUG_PRINT_LOW("DS Disabled : height = %d , width = %d", fmt.fmt.pix_mp.height,fmt.fmt.pix_mp.width); ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt); fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; fmt.fmt.pix_mp.pixelformat = capture_capability; ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt); if (ret) { DEBUG_PRINT_ERROR("Set Resolution failed"); eRet = errno == EBUSY ? OMX_ErrorInsufficientResources : OMX_ErrorUnsupportedSetting; } else { eRet = get_buffer_req(&drv_ctx.op_buf); } if (eRet) break; } } if (m_custom_buffersize.input_buffersize && (portDefn->nBufferSize > m_custom_buffersize.input_buffersize)) { DEBUG_PRINT_ERROR("ERROR: Custom buffer size set by client: %d, trying to set: %d", m_custom_buffersize.input_buffersize, portDefn->nBufferSize); eRet = OMX_ErrorBadParameter; break; } if (portDefn->nBufferCountActual > MAX_NUM_INPUT_OUTPUT_BUFFERS) { DEBUG_PRINT_ERROR("Requested i/p buf count (%u) exceeds limit (%u)", portDefn->nBufferCountActual, MAX_NUM_INPUT_OUTPUT_BUFFERS); eRet = OMX_ErrorBadParameter; break; } // Buffer count can change only when port is unallocated if (m_inp_mem_ptr && (portDefn->nBufferCountActual != drv_ctx.ip_buf.actualcount || portDefn->nBufferSize != drv_ctx.ip_buf.buffer_size)) { DEBUG_PRINT_ERROR("Cannot change i/p buffer count since all buffers are not freed yet !"); eRet = OMX_ErrorInvalidState; break; } if (portDefn->nBufferCountActual >= drv_ctx.ip_buf.mincount || portDefn->nBufferSize != drv_ctx.ip_buf.buffer_size) { port_format_changed = true; vdec_allocatorproperty *buffer_prop = &drv_ctx.ip_buf; drv_ctx.ip_buf.actualcount = portDefn->nBufferCountActual; drv_ctx.ip_buf.buffer_size = (portDefn->nBufferSize + buffer_prop->alignment - 1) & (~(buffer_prop->alignment - 1)); eRet = set_buffer_req(buffer_prop); } if (false == port_format_changed) { DEBUG_PRINT_ERROR("ERROR: IP Requirements(#%d: %u) Requested(#%u: %u)", drv_ctx.ip_buf.mincount, (unsigned int)drv_ctx.ip_buf.buffer_size, (unsigned int)portDefn->nBufferCountActual, (unsigned int)portDefn->nBufferSize); eRet = OMX_ErrorBadParameter; } } else if (portDefn->eDir == OMX_DirMax) { DEBUG_PRINT_ERROR(" Set_parameter: Bad Port idx %d", (int)portDefn->nPortIndex); eRet = OMX_ErrorBadPortIndex; } } break; case OMX_IndexParamVideoPortFormat: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PORTFORMATTYPE); OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData; int ret=0; struct v4l2_format fmt; DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat 0x%x, port: %u", portFmt->eColorFormat, (unsigned int)portFmt->nPortIndex); memset(&fmt, 0x0, sizeof(struct v4l2_format)); if (1 == portFmt->nPortIndex) { fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt); if (ret < 0) { DEBUG_PRINT_ERROR("%s: Failed to get format on capture mplane", __func__); return OMX_ErrorBadParameter; } enum vdec_output_format op_format; if (portFmt->eColorFormat == (OMX_COLOR_FORMATTYPE) QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m) { op_format = (enum vdec_output_format)VDEC_YUV_FORMAT_NV12; fmt.fmt.pix_mp.pixelformat = capture_capability = V4L2_PIX_FMT_NV12; //check if the required color format is a supported flexible format is_flexible_format = check_supported_flexible_formats(portFmt->eColorFormat); } else if (portFmt->eColorFormat == (OMX_COLOR_FORMATTYPE) QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed || portFmt->eColorFormat == OMX_COLOR_FormatYUV420Planar || portFmt->eColorFormat == OMX_COLOR_FormatYUV420SemiPlanar || portFmt->eColorFormat == OMX_COLOR_Format16bitRGB565) { if (!m_disable_ubwc_mode) { op_format = (enum vdec_output_format)VDEC_YUV_FORMAT_NV12_UBWC; fmt.fmt.pix_mp.pixelformat = capture_capability = V4L2_PIX_FMT_NV12_UBWC; } else { op_format = (enum vdec_output_format)VDEC_YUV_FORMAT_NV12; fmt.fmt.pix_mp.pixelformat = capture_capability = V4L2_PIX_FMT_NV12; } //check if the required color format is a supported flexible format is_flexible_format = check_supported_flexible_formats(portFmt->eColorFormat); } else { eRet = OMX_ErrorBadParameter; } if (eRet == OMX_ErrorNone) { drv_ctx.output_format = op_format; ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt); if (ret) { DEBUG_PRINT_ERROR("Set output format failed"); eRet = OMX_ErrorUnsupportedSetting; /*TODO: How to handle this case */ } else { eRet = get_buffer_req(&drv_ctx.op_buf); } } if (eRet == OMX_ErrorNone) { if (!client_buffers.set_color_format(portFmt->eColorFormat)) { DEBUG_PRINT_ERROR("Set color format failed"); eRet = OMX_ErrorBadParameter; } } } } break; case OMX_QTIIndexParamVideoClientExtradata: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTRADATA_ENABLE); QOMX_EXTRADATA_ENABLE *pParam = (QOMX_EXTRADATA_ENABLE *)paramData; DEBUG_PRINT_LOW("set_parameter: OMX_QTIIndexParamVideoClientExtradata %d", pParam->bEnable); if (m_state != OMX_StateLoaded) { DEBUG_PRINT_ERROR("Set Parameter called in Invalid state"); return OMX_ErrorIncorrectStateOperation; } if (pParam->nPortIndex == OMX_CORE_OUTPUT_EXTRADATA_INDEX) { m_client_out_extradata_info.enable_client_extradata(pParam->bEnable); } else { DEBUG_PRINT_ERROR("Incorrect portIndex - %d", pParam->nPortIndex); eRet = OMX_ErrorUnsupportedIndex; } break; } case OMX_IndexParamStandardComponentRole: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_COMPONENTROLETYPE); OMX_PARAM_COMPONENTROLETYPE *comp_role; comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData; DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamStandardComponentRole %s", comp_role->cRole); if ((m_state == OMX_StateLoaded)&& !BITMASK_PRESENT(&m_flags, OMX_COMPONENT_IDLE_PENDING)) { DEBUG_PRINT_LOW("Set Parameter called in valid state"); } else { DEBUG_PRINT_ERROR("Set Parameter called in Invalid State"); return OMX_ErrorIncorrectStateOperation; } if (!strncmp(drv_ctx.kind, "OMX.qcom.video.decoder.avc", OMX_MAX_STRINGNAME_SIZE)) { if (!strncmp((char*)comp_role->cRole, "video_decoder.avc", OMX_MAX_STRINGNAME_SIZE)) { strlcpy((char*)m_cRole, "video_decoder.avc", OMX_MAX_STRINGNAME_SIZE); } else { DEBUG_PRINT_ERROR("Setparameter: unknown Index %s", comp_role->cRole); eRet =OMX_ErrorUnsupportedSetting; } } else if (!strncmp(drv_ctx.kind, "OMX.qcom.video.decoder.mpeg2", OMX_MAX_STRINGNAME_SIZE)) { if (!strncmp((const char*)comp_role->cRole, "video_decoder.mpeg2", OMX_MAX_STRINGNAME_SIZE)) { strlcpy((char*)m_cRole, "video_decoder.mpeg2", OMX_MAX_STRINGNAME_SIZE); } else { DEBUG_PRINT_ERROR("Setparameter: unknown Index %s", comp_role->cRole); eRet = OMX_ErrorUnsupportedSetting; } } else if (!strncmp(drv_ctx.kind, "OMX.qcom.video.decoder.vp8", OMX_MAX_STRINGNAME_SIZE)) { if (!strncmp((const char*)comp_role->cRole, "video_decoder.vp8", OMX_MAX_STRINGNAME_SIZE) || !strncmp((const char*)comp_role->cRole, "video_decoder.vpx", OMX_MAX_STRINGNAME_SIZE)) { strlcpy((char*)m_cRole, "video_decoder.vp8", OMX_MAX_STRINGNAME_SIZE); } else { DEBUG_PRINT_ERROR("Setparameter: unknown Index %s", comp_role->cRole); eRet = OMX_ErrorUnsupportedSetting; } } else if (!strncmp(drv_ctx.kind, "OMX.qcom.video.decoder.vp9", OMX_MAX_STRINGNAME_SIZE)) { if (!strncmp((const char*)comp_role->cRole, "video_decoder.vp9", OMX_MAX_STRINGNAME_SIZE) || !strncmp((const char*)comp_role->cRole, "video_decoder.vpx", OMX_MAX_STRINGNAME_SIZE)) { strlcpy((char*)m_cRole, "video_decoder.vp9", OMX_MAX_STRINGNAME_SIZE); } else { DEBUG_PRINT_ERROR("Setparameter: unknown Index %s", comp_role->cRole); eRet = OMX_ErrorUnsupportedSetting; } } else if (!strncmp(drv_ctx.kind, "OMX.qcom.video.decoder.hevc", OMX_MAX_STRINGNAME_SIZE)) { if (!strncmp((const char*)comp_role->cRole, "video_decoder.hevc", OMX_MAX_STRINGNAME_SIZE)) { strlcpy((char*)m_cRole, "video_decoder.hevc", OMX_MAX_STRINGNAME_SIZE); } else { DEBUG_PRINT_ERROR("Setparameter: unknown Index %s", comp_role->cRole); eRet = OMX_ErrorUnsupportedSetting; } } else { DEBUG_PRINT_ERROR("Setparameter: unknown param %s", drv_ctx.kind); eRet = OMX_ErrorInvalidComponentName; } break; } case OMX_IndexParamPriorityMgmt: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PRIORITYMGMTTYPE); if (m_state != OMX_StateLoaded) { DEBUG_PRINT_ERROR("Set Parameter called in Invalid State"); return OMX_ErrorIncorrectStateOperation; } OMX_PRIORITYMGMTTYPE *priorityMgmtype = (OMX_PRIORITYMGMTTYPE*) paramData; DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt %u", (unsigned int)priorityMgmtype->nGroupID); DEBUG_PRINT_LOW("set_parameter: priorityMgmtype %u", (unsigned int)priorityMgmtype->nGroupPriority); m_priority_mgm.nGroupID = priorityMgmtype->nGroupID; m_priority_mgm.nGroupPriority = priorityMgmtype->nGroupPriority; break; } case OMX_IndexParamCompBufferSupplier: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_BUFFERSUPPLIERTYPE); OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData; DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier %d", bufferSupplierType->eBufferSupplier); if (bufferSupplierType->nPortIndex == 0 || bufferSupplierType->nPortIndex ==1) m_buffer_supplier.eBufferSupplier = bufferSupplierType->eBufferSupplier; else eRet = OMX_ErrorBadPortIndex; break; } case OMX_IndexParamVideoAvc: { DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAvc %d", paramIndex); break; } case (OMX_INDEXTYPE)QOMX_IndexParamVideoMvc: { DEBUG_PRINT_LOW("set_parameter: QOMX_IndexParamVideoMvc %d", paramIndex); break; } case OMX_IndexParamVideoMpeg2: { DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoMpeg2 %d", paramIndex); break; } case OMX_QTIIndexParamLowLatencyMode: { struct v4l2_control control; int rc = 0; QOMX_EXTNINDEX_VIDEO_LOW_LATENCY_MODE* pParam = (QOMX_EXTNINDEX_VIDEO_LOW_LATENCY_MODE*)paramData; control.id = V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_MODE; if (pParam->bEnableLowLatencyMode) control.value = V4L2_MPEG_MSM_VIDC_ENABLE; else control.value = V4L2_MPEG_MSM_VIDC_DISABLE; rc = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_CTRL, &control); if (rc) { DEBUG_PRINT_ERROR("Set low latency failed"); eRet = OMX_ErrorUnsupportedSetting; } else { m_sParamLowLatency.bEnableLowLatencyMode = pParam->bEnableLowLatencyMode; } break; } case OMX_QcomIndexParamVideoDecoderPictureOrder: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_DECODER_PICTURE_ORDER); QOMX_VIDEO_DECODER_PICTURE_ORDER *pictureOrder = (QOMX_VIDEO_DECODER_PICTURE_ORDER *)paramData; struct v4l2_control control; int pic_order,rc=0; DEBUG_PRINT_HIGH("set_parameter: OMX_QcomIndexParamVideoDecoderPictureOrder %d", pictureOrder->eOutputPictureOrder); if (pictureOrder->eOutputPictureOrder == QOMX_VIDEO_DISPLAY_ORDER) { pic_order = V4L2_MPEG_MSM_VIDC_DISABLE; } else if (pictureOrder->eOutputPictureOrder == QOMX_VIDEO_DECODE_ORDER) { pic_order = V4L2_MPEG_MSM_VIDC_ENABLE; time_stamp_dts.set_timestamp_reorder_mode(false); } else eRet = OMX_ErrorBadParameter; if (eRet == OMX_ErrorNone) { control.id = V4L2_CID_MPEG_VIDC_VIDEO_DECODE_ORDER; control.value = pic_order; rc = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_CTRL, &control); if (rc) { DEBUG_PRINT_ERROR("Set picture order failed"); eRet = OMX_ErrorUnsupportedSetting; } } m_decode_order_mode = pictureOrder->eOutputPictureOrder == QOMX_VIDEO_DECODE_ORDER; break; } case OMX_QcomIndexParamVideoSyncFrameDecodingMode: { DEBUG_PRINT_HIGH("set_parameter: OMX_QcomIndexParamVideoSyncFrameDecodingMode"); DEBUG_PRINT_HIGH("set idr only decoding for thumbnail mode"); struct v4l2_control control; int rc; drv_ctx.idr_only_decoding = 1; control.id = V4L2_CID_MPEG_VIDC_VIDEO_DECODE_ORDER; control.value = V4L2_MPEG_MSM_VIDC_ENABLE; rc = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_CTRL, &control); if (rc) { DEBUG_PRINT_ERROR("Set picture order failed"); eRet = OMX_ErrorUnsupportedSetting; } else { control.id = V4L2_CID_MPEG_VIDC_VIDEO_SYNC_FRAME_DECODE; control.value = V4L2_MPEG_MSM_VIDC_ENABLE; rc = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_CTRL, &control); if (rc) { DEBUG_PRINT_ERROR("Sync frame setting failed"); eRet = OMX_ErrorUnsupportedSetting; } /*Setting sync frame decoding on driver might change buffer * requirements so update them here*/ if (get_buffer_req(&drv_ctx.ip_buf)) { DEBUG_PRINT_ERROR("Sync frame setting failed: falied to get buffer i/p requirements"); eRet = OMX_ErrorUnsupportedSetting; } if (get_buffer_req(&drv_ctx.op_buf)) { DEBUG_PRINT_ERROR("Sync frame setting failed: falied to get buffer o/p requirements"); eRet = OMX_ErrorUnsupportedSetting; } } } break; case OMX_QcomIndexParamIndexExtraDataType: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_INDEXEXTRADATATYPE); QOMX_INDEXEXTRADATATYPE *extradataIndexType = (QOMX_INDEXEXTRADATATYPE *) paramData; DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexParamIndexExtraDataType %d", extradataIndexType->nIndex); if (extradataIndexType->nIndex == (OMX_INDEXTYPE)OMX_QTI_ExtraDataCategory_Basic) { m_client_extradata |= EXTRADATA_DEFAULT; } else if (extradataIndexType->nIndex == (OMX_INDEXTYPE)OMX_QTI_ExtraDataCategory_Advanced) { m_client_extradata |= EXTRADATA_ADVANCED; } if (m_client_extradata) { eRet = enable_extradata(m_client_extradata); } break; } #if defined (_ANDROID_HONEYCOMB_) || defined (_ANDROID_ICS_) /* Need to allow following two set_parameters even in Idle * state. This is ANDROID architecture which is not in sync * with openmax standard. */ case OMX_GoogleAndroidIndexEnableAndroidNativeBuffers: { VALIDATE_OMX_PARAM_DATA(paramData, EnableAndroidNativeBuffersParams); EnableAndroidNativeBuffersParams* enableNativeBuffers = (EnableAndroidNativeBuffersParams *) paramData; if (enableNativeBuffers->nPortIndex != OMX_CORE_OUTPUT_PORT_INDEX) { DEBUG_PRINT_ERROR("Enable/Disable android-native-buffers allowed only on output port!"); eRet = OMX_ErrorUnsupportedSetting; break; } else if (m_out_mem_ptr) { DEBUG_PRINT_ERROR("Enable/Disable android-native-buffers is not allowed since Output port is not free !"); eRet = OMX_ErrorInvalidState; break; } if (enableNativeBuffers) { m_enable_android_native_buffers = enableNativeBuffers->enable; } #if !defined(FLEXYUV_SUPPORTED) if (m_enable_android_native_buffers) { // Use the most-preferred-native-color-format as surface-mode is hinted here if(!client_buffers.set_color_format(getPreferredColorFormatDefaultMode(0))) { DEBUG_PRINT_ERROR("Failed to set native color format!"); eRet = OMX_ErrorUnsupportedSetting; } } #endif } break; case OMX_GoogleAndroidIndexUseAndroidNativeBuffer: { VALIDATE_OMX_PARAM_DATA(paramData, UseAndroidNativeBufferParams); eRet = use_android_native_buffer(hComp, paramData); } break; #if ALLOCATE_OUTPUT_NATIVEHANDLE case OMX_GoogleAndroidIndexAllocateNativeHandle: { AllocateNativeHandleParams* allocateNativeHandleParams = (AllocateNativeHandleParams *) paramData; VALIDATE_OMX_PARAM_DATA(paramData, AllocateNativeHandleParams); if (allocateNativeHandleParams->nPortIndex != OMX_CORE_INPUT_PORT_INDEX) { DEBUG_PRINT_LOW("Enable/Disable allocate-native-handle allowed only on input port!. Please ignore this Unsupported Setting (0x80001019)."); eRet = OMX_ErrorUnsupportedSetting; break; } else if (m_inp_mem_ptr) { DEBUG_PRINT_ERROR("Enable/Disable allocate-native-handle is not allowed since Input port is not free !"); eRet = OMX_ErrorInvalidState; break; } if (allocateNativeHandleParams != NULL) { allocate_native_handle = allocateNativeHandleParams->enable; } } break; #endif //ALLOCATE_OUTPUT_NATIVEHANDLE #endif case OMX_QcomIndexParamEnableTimeStampReorder: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_INDEXTIMESTAMPREORDER); QOMX_INDEXTIMESTAMPREORDER *reorder = (QOMX_INDEXTIMESTAMPREORDER *)paramData; if (drv_ctx.picture_order == (vdec_output_order)QOMX_VIDEO_DISPLAY_ORDER) { if (reorder->bEnable == OMX_TRUE) { frm_int =0; time_stamp_dts.set_timestamp_reorder_mode(true); } else time_stamp_dts.set_timestamp_reorder_mode(false); } else { time_stamp_dts.set_timestamp_reorder_mode(false); if (reorder->bEnable == OMX_TRUE) { eRet = OMX_ErrorUnsupportedSetting; } } } break; case OMX_IndexParamVideoProfileLevelCurrent: { VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PROFILELEVELTYPE); OMX_VIDEO_PARAM_PROFILELEVELTYPE *pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData; DEBUG_PRINT_LOW("set_parameter: Client set profile is: %d", pParam->eProfile); DEBUG_PRINT_LOW("set_parameter: Client set level is: %d", pParam->eLevel); clientSet_profile_level.eProfile = pParam->eProfile; clientSet_profile_level.eLevel = pParam->eLevel; break; } case OMX_QTIIndexParamVideoDecoderOutputFrameRate: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_OUTPUT_FRAME_RATE); DEBUG_PRINT_LOW("set_parameter: OMX_QTIIndexParamVideoDecoderOutputFrameRate"); QOMX_VIDEO_OUTPUT_FRAME_RATE *pParam = (QOMX_VIDEO_OUTPUT_FRAME_RATE*)paramData; DEBUG_PRINT_LOW("set_parameter: decoder output-frame-rate %d", pParam->fps); m_dec_hfr_fps=pParam->fps; if (m_dec_hfr_fps > m_dec_output_rate) m_dec_hfr_fps = m_dec_output_rate; DEBUG_PRINT_HIGH("output-frame-rate value = %d", m_dec_hfr_fps); break; } case OMX_QcomIndexParamVideoMetaBufferMode: { VALIDATE_OMX_PARAM_DATA(paramData, StoreMetaDataInBuffersParams); StoreMetaDataInBuffersParams *metabuffer = (StoreMetaDataInBuffersParams *)paramData; if (!metabuffer) { DEBUG_PRINT_ERROR("Invalid param: %p", metabuffer); eRet = OMX_ErrorBadParameter; break; } if (m_disable_dynamic_buf_mode) { DEBUG_PRINT_HIGH("Dynamic buffer mode is disabled"); eRet = OMX_ErrorUnsupportedSetting; break; } if (metabuffer->nPortIndex == OMX_CORE_OUTPUT_PORT_INDEX) { if (m_out_mem_ptr) { DEBUG_PRINT_ERROR("Enable/Disable dynamic-buffer-mode is not allowed since Output port is not free !"); eRet = OMX_ErrorInvalidState; break; } dynamic_buf_mode = metabuffer->bStoreMetaData; DEBUG_PRINT_HIGH("%s buffer mode", (metabuffer->bStoreMetaData == true)? "Enabled dynamic" : "Disabled dynamic"); } else { DEBUG_PRINT_ERROR( "OMX_QcomIndexParamVideoMetaBufferMode not supported for port: %u", (unsigned int)metabuffer->nPortIndex); eRet = OMX_ErrorUnsupportedSetting; } break; } case OMX_QcomIndexParamVideoCustomBufferSize: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_CUSTOM_BUFFERSIZE); DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexParamVideoCustomBufferSize"); QOMX_VIDEO_CUSTOM_BUFFERSIZE* pParam = (QOMX_VIDEO_CUSTOM_BUFFERSIZE*)paramData; if (pParam->nPortIndex == OMX_CORE_INPUT_PORT_INDEX) { struct v4l2_control control; control.id = V4L2_CID_MPEG_VIDC_VIDEO_BUFFER_SIZE_LIMIT; control.value = pParam->nBufferSize; if (ioctl(drv_ctx.video_driver_fd, VIDIOC_S_CTRL, &control)) { DEBUG_PRINT_ERROR("Failed to set input buffer size"); eRet = OMX_ErrorUnsupportedSetting; } else { eRet = get_buffer_req(&drv_ctx.ip_buf); if (eRet == OMX_ErrorNone) { m_custom_buffersize.input_buffersize = drv_ctx.ip_buf.buffer_size; DEBUG_PRINT_HIGH("Successfully set custom input buffer size = %d", m_custom_buffersize.input_buffersize); } else { DEBUG_PRINT_ERROR("Failed to get buffer requirement"); } } } else { DEBUG_PRINT_ERROR("ERROR: Custom buffer size in not supported on output port"); eRet = OMX_ErrorBadParameter; } break; } case OMX_QTIIndexParamPassInputBufferFd: { VALIDATE_OMX_PARAM_DATA(paramData, QOMX_ENABLETYPE); m_input_pass_buffer_fd = ((QOMX_ENABLETYPE *)paramData)->bEnable; if (m_input_pass_buffer_fd) DEBUG_PRINT_LOW("Enable passing input buffer FD"); break; } case OMX_QTIIndexParamForceUnCompressedForOPB: { DEBUG_PRINT_LOW("set_parameter: OMX_QTIIndexParamForceUnCompressedForOPB"); OMX_QTI_VIDEO_PARAM_FORCE_UNCOMPRESSED_FOR_OPB_TYPE *pParam = (OMX_QTI_VIDEO_PARAM_FORCE_UNCOMPRESSED_FOR_OPB_TYPE *)paramData; if (!paramData) { DEBUG_PRINT_ERROR("set_parameter: OMX_QTIIndexParamForceUnCompressedForOPB paramData is NULL"); eRet = OMX_ErrorBadParameter; break; } m_disable_ubwc_mode = pParam->bEnable; DEBUG_PRINT_LOW("set_parameter: UBWC %s for OPB", pParam->bEnable ? "disabled" : "enabled"); break; } default: { DEBUG_PRINT_ERROR("Setparameter: unknown param %d", paramIndex); eRet = OMX_ErrorUnsupportedIndex; } } if (eRet != OMX_ErrorNone) DEBUG_PRINT_ERROR("set_parameter: Error: 0x%x, setting param 0x%x", eRet, paramIndex); return eRet; }