| /* |
| * Copyright (C) Texas Instruments - http://www.ti.com/ |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file OMXCameraAdapter.cpp |
| * |
| * This file maps the Camera Hardware Interface to OMX. |
| * |
| */ |
| |
| #include "CameraHal.h" |
| #include "OMXCameraAdapter.h" |
| #include "OMXDCC.h" |
| #include "ErrorUtils.h" |
| #include "TICameraParameters.h" |
| #include <signal.h> |
| #include <math.h> |
| |
| #include <cutils/properties.h> |
| #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) |
| static int mDebugFps = 0; |
| static int mDebugFcs = 0; |
| |
| #define HERE(Msg) {CAMHAL_LOGEB("--===line %d, %s===--\n", __LINE__, Msg);} |
| |
| namespace Ti { |
| namespace Camera { |
| |
| #ifdef CAMERAHAL_OMX_PROFILING |
| |
| const char OMXCameraAdapter::DEFAULT_PROFILE_PATH[] = "/data/dbg/profile_data.bin"; |
| |
| #endif |
| |
| //frames skipped before recalculating the framerate |
| #define FPS_PERIOD 30 |
| |
| android::Mutex gAdapterLock; |
| /*--------------------Camera Adapter Class STARTS here-----------------------------*/ |
| |
| status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps) |
| { |
| LOG_FUNCTION_NAME; |
| |
| char value[PROPERTY_VALUE_MAX]; |
| const char *mountOrientationString = NULL; |
| |
| property_get("debug.camera.showfps", value, "0"); |
| mDebugFps = atoi(value); |
| property_get("debug.camera.framecounts", value, "0"); |
| mDebugFcs = atoi(value); |
| |
| #ifdef CAMERAHAL_OMX_PROFILING |
| |
| property_get("debug.camera.profile", value, "0"); |
| mDebugProfile = atoi(value); |
| |
| #endif |
| |
| TIMM_OSAL_ERRORTYPE osalError = OMX_ErrorNone; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| status_t ret = NO_ERROR; |
| |
| mLocalVersionParam.s.nVersionMajor = 0x1; |
| mLocalVersionParam.s.nVersionMinor = 0x1; |
| mLocalVersionParam.s.nRevision = 0x0 ; |
| mLocalVersionParam.s.nStep = 0x0; |
| |
| mPending3Asettings = 0;//E3AsettingsAll; |
| mPendingCaptureSettings = 0; |
| mPendingPreviewSettings = 0; |
| mPendingReprocessSettings = 0; |
| |
| ret = mMemMgr.initialize(); |
| if ( ret != OK ) { |
| CAMHAL_LOGE("MemoryManager initialization failed, error: %d", ret); |
| return ret; |
| } |
| |
| if ( 0 != mInitSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mInitSem semaphore count %d", mInitSem.Count()); |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_INIT; |
| } |
| |
| ///Update the preview and image capture port indexes |
| mCameraAdapterParameters.mPrevPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW; |
| // temp changed in order to build OMX_CAMERA_PORT_VIDEO_OUT_IMAGE; |
| mCameraAdapterParameters.mImagePortIndex = OMX_CAMERA_PORT_IMAGE_OUT_IMAGE; |
| mCameraAdapterParameters.mMeasurementPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT; |
| //currently not supported use preview port instead |
| mCameraAdapterParameters.mVideoPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_VIDEO; |
| mCameraAdapterParameters.mVideoInPortIndex = OMX_CAMERA_PORT_VIDEO_IN_VIDEO; |
| |
| eError = OMX_Init(); |
| if (eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_Init() failed, error: 0x%x", eError); |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| mOmxInitialized = true; |
| |
| // Initialize the callback handles |
| OMX_CALLBACKTYPE callbacks; |
| callbacks.EventHandler = Camera::OMXCameraAdapterEventHandler; |
| callbacks.EmptyBufferDone = Camera::OMXCameraAdapterEmptyBufferDone; |
| callbacks.FillBufferDone = Camera::OMXCameraAdapterFillBufferDone; |
| |
| ///Get the handle to the OMX Component |
| eError = OMXCameraAdapter::OMXCameraGetHandle(&mCameraAdapterParameters.mHandleComp, this, callbacks); |
| if(eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError); |
| } |
| GOTO_EXIT_IF((eError != OMX_ErrorNone), eError); |
| |
| mComponentState = OMX_StateLoaded; |
| |
| CAMHAL_LOGVB("OMX_GetHandle -0x%x sensor_index = %lu", eError, mSensorIndex); |
| initDccFileDataSave(&mCameraAdapterParameters.mHandleComp, mCameraAdapterParameters.mPrevPortIndex); |
| |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortDisable, |
| OMX_ALL, |
| NULL); |
| |
| if(eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortDisable) -0x%x", eError); |
| } |
| GOTO_EXIT_IF((eError != OMX_ErrorNone), eError); |
| |
| // Register for port enable event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| mInitSem); |
| if(ret != NO_ERROR) { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| // Enable PREVIEW Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| NULL); |
| if(eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| // Wait for the port enable event to occur |
| ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| if ( NO_ERROR == ret ) { |
| CAMHAL_LOGDA("-Port enable event arrived"); |
| } else { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| NULL); |
| CAMHAL_LOGEA("Timeout for enabling preview port expired!"); |
| goto EXIT; |
| } |
| |
| // Select the sensor |
| OMX_CONFIG_SENSORSELECTTYPE sensorSelect; |
| OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE); |
| sensorSelect.eSensor = (OMX_SENSORSELECT) mSensorIndex; |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while selecting the sensor index as %d - 0x%x", mSensorIndex, eError); |
| return BAD_VALUE; |
| } else { |
| CAMHAL_LOGDB("Sensor %d selected successfully", mSensorIndex); |
| } |
| |
| #ifdef CAMERAHAL_DEBUG |
| |
| printComponentVersion(mCameraAdapterParameters.mHandleComp); |
| |
| #endif |
| |
| mBracketingEnabled = false; |
| mZoomBracketingEnabled = false; |
| mBracketingBuffersQueuedCount = 0; |
| mBracketingRange = 1; |
| mLastBracetingBufferIdx = 0; |
| mBracketingBuffersQueued = NULL; |
| mOMXStateSwitch = false; |
| mBracketingSet = false; |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| mRawCapture = false; |
| mYuvCapture = false; |
| #endif |
| |
| mCaptureSignalled = false; |
| mCaptureConfigured = false; |
| mReprocConfigured = false; |
| mRecording = false; |
| mWaitingForSnapshot = false; |
| mPictureFormatFromClient = NULL; |
| |
| mCapabilitiesOpMode = MODE_MAX; |
| mCapMode = INITIAL_MODE; |
| mIPP = IPP_NULL; |
| mVstabEnabled = false; |
| mVnfEnabled = false; |
| mBurstFrames = 1; |
| mFlushShotConfigQueue = false; |
| mPictureQuality = 100; |
| mCurrentZoomIdx = 0; |
| mTargetZoomIdx = 0; |
| mPreviousZoomIndx = 0; |
| mReturnZoomStatus = false; |
| mZoomInc = 1; |
| mZoomParameterIdx = 0; |
| mExposureBracketingValidEntries = 0; |
| mZoomBracketingValidEntries = 0; |
| mSensorOverclock = false; |
| mAutoConv = OMX_TI_AutoConvergenceModeMax; |
| mManualConv = 0; |
| |
| #ifdef CAMERAHAL_TUNA |
| mIternalRecordingHint = false; |
| #endif |
| |
| mDeviceOrientation = 0; |
| mFaceOrientation = 0; |
| mCapabilities = caps; |
| mZoomUpdating = false; |
| mZoomUpdate = false; |
| mGBCE = BRIGHTNESS_OFF; |
| mGLBCE = BRIGHTNESS_OFF; |
| mParameters3A.ExposureLock = OMX_FALSE; |
| mParameters3A.WhiteBalanceLock = OMX_FALSE; |
| |
| mEXIFData.mGPSData.mAltitudeValid = false; |
| mEXIFData.mGPSData.mDatestampValid = false; |
| mEXIFData.mGPSData.mLatValid = false; |
| mEXIFData.mGPSData.mLongValid = false; |
| mEXIFData.mGPSData.mMapDatumValid = false; |
| mEXIFData.mGPSData.mProcMethodValid = false; |
| mEXIFData.mGPSData.mVersionIdValid = false; |
| mEXIFData.mGPSData.mTimeStampValid = false; |
| mEXIFData.mModelValid = false; |
| mEXIFData.mMakeValid = false; |
| |
| mCapturedFrames = 0; |
| mBurstFramesAccum = 0; |
| mBurstFramesQueued = 0; |
| |
| //update the mDeviceOrientation with the sensor mount orientation. |
| //So that the face detect will work before onOrientationEvent() |
| //get triggered. |
| CAMHAL_ASSERT(mCapabilities); |
| mountOrientationString = mCapabilities->get(CameraProperties::ORIENTATION_INDEX); |
| CAMHAL_ASSERT(mountOrientationString); |
| mDeviceOrientation = atoi(mountOrientationString); |
| mFaceOrientation = atoi(mountOrientationString); |
| |
| if (mSensorIndex != 2) { |
| mCapabilities->setMode(MODE_HIGH_SPEED); |
| } |
| |
| if (mCapabilities->get(CameraProperties::SUPPORTED_ZOOM_STAGES) != NULL) { |
| mMaxZoomSupported = mCapabilities->getInt(CameraProperties::SUPPORTED_ZOOM_STAGES) + 1; |
| } else { |
| mMaxZoomSupported = 1; |
| } |
| |
| // initialize command handling thread |
| if(mCommandHandler.get() == NULL) |
| mCommandHandler = new CommandHandler(this); |
| |
| if ( NULL == mCommandHandler.get() ) |
| { |
| CAMHAL_LOGEA("Couldn't create command handler"); |
| return NO_MEMORY; |
| } |
| |
| ret = mCommandHandler->run("CallbackThread", android::PRIORITY_URGENT_DISPLAY); |
| if ( ret != NO_ERROR ) |
| { |
| if( ret == INVALID_OPERATION){ |
| CAMHAL_LOGDA("command handler thread already runnning!!"); |
| ret = NO_ERROR; |
| } else { |
| CAMHAL_LOGEA("Couldn't run command handlerthread"); |
| return ret; |
| } |
| } |
| |
| // initialize omx callback handling thread |
| if(mOMXCallbackHandler.get() == NULL) |
| mOMXCallbackHandler = new OMXCallbackHandler(this); |
| |
| if ( NULL == mOMXCallbackHandler.get() ) |
| { |
| CAMHAL_LOGEA("Couldn't create omx callback handler"); |
| return NO_MEMORY; |
| } |
| |
| ret = mOMXCallbackHandler->run("OMXCallbackThread", android::PRIORITY_URGENT_DISPLAY); |
| if ( ret != NO_ERROR ) |
| { |
| if( ret == INVALID_OPERATION){ |
| CAMHAL_LOGDA("omx callback handler thread already runnning!!"); |
| ret = NO_ERROR; |
| } else { |
| CAMHAL_LOGEA("Couldn't run omx callback handler thread"); |
| return ret; |
| } |
| } |
| |
| OMX_INIT_STRUCT_PTR (&mRegionPriority, OMX_TI_CONFIG_3A_REGION_PRIORITY); |
| OMX_INIT_STRUCT_PTR (&mFacePriority, OMX_TI_CONFIG_3A_FACE_PRIORITY); |
| mRegionPriority.nPortIndex = OMX_ALL; |
| mFacePriority.nPortIndex = OMX_ALL; |
| |
| //Setting this flag will that the first setParameter call will apply all 3A settings |
| //and will not conditionally apply based on current values. |
| mFirstTimeInit = true; |
| |
| //Flag to avoid calling setVFramerate() before OMX_SetParameter(OMX_IndexParamPortDefinition) |
| //Ducati will return an error otherwise. |
| mSetFormatDone = false; |
| |
| memset(mExposureBracketingValues, 0, EXP_BRACKET_RANGE*sizeof(int)); |
| memset(mZoomBracketingValues, 0, ZOOM_BRACKET_RANGE*sizeof(int)); |
| mMeasurementEnabled = false; |
| mFaceDetectionRunning = false; |
| mFaceDetectionPaused = false; |
| mFDSwitchAlgoPriority = false; |
| |
| metadataLastAnalogGain = -1; |
| metadataLastExposureTime = -1; |
| |
| memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex], 0, sizeof(OMXCameraPortParameters)); |
| memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], 0, sizeof(OMXCameraPortParameters)); |
| memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex], 0, sizeof(OMXCameraPortParameters)); |
| memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoInPortIndex], 0, sizeof(OMXCameraPortParameters)); |
| |
| // initialize 3A defaults |
| mParameters3A.Effect = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EFFECT, EffLUT); |
| mParameters3A.FlashMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FLASH_MODE, FlashLUT); |
| mParameters3A.SceneMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_SCENE_MODE, SceneLUT); |
| mParameters3A.EVCompensation = atoi(OMXCameraAdapter::DEFAULT_EV_COMPENSATION); |
| mParameters3A.Focus = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FOCUS_MODE, FocusLUT); |
| mParameters3A.ISO = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ISO_MODE, IsoLUT); |
| mParameters3A.Flicker = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ANTIBANDING, FlickerLUT); |
| mParameters3A.Brightness = atoi(OMXCameraAdapter::DEFAULT_BRIGHTNESS); |
| mParameters3A.Saturation = atoi(OMXCameraAdapter::DEFAULT_SATURATION) - SATURATION_OFFSET; |
| mParameters3A.Sharpness = atoi(OMXCameraAdapter::DEFAULT_SHARPNESS) - SHARPNESS_OFFSET; |
| mParameters3A.Contrast = atoi(OMXCameraAdapter::DEFAULT_CONTRAST) - CONTRAST_OFFSET; |
| mParameters3A.WhiteBallance = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_WB, WBalLUT); |
| mParameters3A.Exposure = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EXPOSURE_MODE, ExpLUT); |
| mParameters3A.ExposureLock = OMX_FALSE; |
| mParameters3A.FocusLock = OMX_FALSE; |
| mParameters3A.WhiteBalanceLock = OMX_FALSE; |
| |
| mParameters3A.ManualExposure = 0; |
| mParameters3A.ManualExposureRight = 0; |
| mParameters3A.ManualGain = 0; |
| mParameters3A.ManualGainRight = 0; |
| |
| mParameters3A.AlgoExternalGamma = OMX_FALSE; |
| mParameters3A.AlgoNSF1 = OMX_TRUE; |
| mParameters3A.AlgoNSF2 = OMX_TRUE; |
| mParameters3A.AlgoSharpening = OMX_TRUE; |
| mParameters3A.AlgoThreeLinColorMap = OMX_TRUE; |
| mParameters3A.AlgoGIC = OMX_TRUE; |
| memset(&mParameters3A.mGammaTable, 0, sizeof(mParameters3A.mGammaTable)); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| |
| EXIT: |
| |
| CAMHAL_LOGDB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| void OMXCameraAdapter::performCleanupAfterError() |
| { |
| if(mCameraAdapterParameters.mHandleComp) |
| { |
| ///Free the OMX component handle in case of error |
| OMX_FreeHandle(mCameraAdapterParameters.mHandleComp); |
| mCameraAdapterParameters.mHandleComp = NULL; |
| } |
| |
| ///De-init the OMX |
| OMX_Deinit(); |
| mComponentState = OMX_StateInvalid; |
| } |
| |
| OMXCameraAdapter::OMXCameraPortParameters *OMXCameraAdapter::getPortParams(CameraFrame::FrameType frameType) |
| { |
| OMXCameraAdapter::OMXCameraPortParameters *ret = NULL; |
| |
| switch ( frameType ) |
| { |
| case CameraFrame::IMAGE_FRAME: |
| ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| break; |
| case CameraFrame::RAW_FRAME: |
| if (mRawCapture) { |
| ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex]; |
| } else { |
| ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| } |
| break; |
| case CameraFrame::PREVIEW_FRAME_SYNC: |
| case CameraFrame::SNAPSHOT_FRAME: |
| case CameraFrame::VIDEO_FRAME_SYNC: |
| ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| break; |
| case CameraFrame::FRAME_DATA_SYNC: |
| ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; |
| break; |
| default: |
| break; |
| }; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::fillThisBuffer(CameraBuffer * frameBuf, CameraFrame::FrameType frameType) |
| { |
| LOG_FUNCTION_NAME; |
| |
| status_t ret = NO_ERROR; |
| OMXCameraPortParameters *port = NULL; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| BaseCameraAdapter::AdapterState state; |
| BaseCameraAdapter::getState(state); |
| bool isCaptureFrame = false; |
| |
| if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE ) |
| { |
| return NO_INIT; |
| } |
| |
| if ( NULL == frameBuf ) |
| { |
| return -EINVAL; |
| } |
| |
| isCaptureFrame = (CameraFrame::IMAGE_FRAME == frameType) || |
| (CameraFrame::RAW_FRAME == frameType); |
| |
| if ( NO_ERROR == ret ) |
| { |
| port = getPortParams(frameType); |
| if ( NULL == port ) |
| { |
| CAMHAL_LOGEB("Invalid frameType 0x%x", frameType); |
| ret = -EINVAL; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) { |
| for ( int i = 0 ; i < port->mNumBufs ; i++) { |
| if ((CameraBuffer *) port->mBufferHeader[i]->pAppPrivate == frameBuf) { |
| if ( isCaptureFrame && !mBracketingEnabled ) { |
| android::AutoMutex lock(mBurstLock); |
| if ((1 > mCapturedFrames) && !mBracketingEnabled && (mCapMode != CP_CAM)) { |
| // Signal end of image capture |
| if ( NULL != mEndImageCaptureCallback) { |
| mEndImageCaptureCallback(mEndCaptureData); |
| } |
| port->mStatus[i] = OMXCameraPortParameters::IDLE; |
| return NO_ERROR; |
| } else if (mBurstFramesQueued >= mBurstFramesAccum) { |
| port->mStatus[i] = OMXCameraPortParameters::IDLE; |
| return NO_ERROR; |
| } |
| mBurstFramesQueued++; |
| } |
| port->mStatus[i] = OMXCameraPortParameters::FILL; |
| eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, port->mBufferHeader[i]); |
| if ( eError != OMX_ErrorNone ) |
| { |
| CAMHAL_LOGEB("OMX_FillThisBuffer 0x%x", eError); |
| goto EXIT; |
| } |
| mFramesWithDucati++; |
| break; |
| } |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return ret; |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| //Since fillthisbuffer is called asynchronously, make sure to signal error to the app |
| mErrorNotifier->errorNotify(CAMERA_ERROR_HARD); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| void OMXCameraAdapter::setParamS3D(OMX_U32 port, const char *valstr) |
| { |
| OMXCameraPortParameters *cap; |
| |
| LOG_FUNCTION_NAME; |
| |
| cap = &mCameraAdapterParameters.mCameraPortParams[port]; |
| if (valstr != NULL) |
| { |
| if (strcmp(valstr, TICameraParameters::S3D_TB_FULL) == 0) |
| { |
| cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutTopBottom; |
| } |
| else if (strcmp(valstr, TICameraParameters::S3D_SS_FULL) == 0) |
| { |
| cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutLeftRight; |
| } |
| else if (strcmp(valstr, TICameraParameters::S3D_TB_SUBSAMPLED) == 0) |
| { |
| cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutTopBottomSubsample; |
| } |
| else if (strcmp(valstr, TICameraParameters::S3D_SS_SUBSAMPLED) == 0) |
| { |
| cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutLeftRightSubsample; |
| } |
| else |
| { |
| cap->mFrameLayoutType = OMX_TI_StereoFrameLayout2D; |
| } |
| } |
| else |
| { |
| cap->mFrameLayoutType = OMX_TI_StereoFrameLayout2D; |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| } |
| |
| status_t OMXCameraAdapter::setParameters(const android::CameraParameters ¶ms) |
| { |
| LOG_FUNCTION_NAME; |
| |
| int mode = 0; |
| status_t ret = NO_ERROR; |
| bool updateImagePortParams = false; |
| int minFramerate, maxFramerate, frameRate; |
| const char *valstr = NULL; |
| int w, h; |
| OMX_COLOR_FORMATTYPE pixFormat; |
| BaseCameraAdapter::AdapterState state; |
| BaseCameraAdapter::getState(state); |
| |
| ///@todo Include more camera parameters |
| if ( (valstr = params.getPreviewFormat()) != NULL ) { |
| if(strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 || |
| strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_YUV420P) == 0 || |
| strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_YUV422I) == 0) { |
| CAMHAL_LOGDA("YUV420SP format selected"); |
| pixFormat = OMX_COLOR_FormatYUV420PackedSemiPlanar; |
| } else if(strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_RGB565) == 0) { |
| CAMHAL_LOGDA("RGB565 format selected"); |
| pixFormat = OMX_COLOR_Format16bitRGB565; |
| } else { |
| CAMHAL_LOGDA("Invalid format, CbYCrY format selected as default"); |
| pixFormat = OMX_COLOR_FormatCbYCrY; |
| } |
| } else { |
| CAMHAL_LOGEA("Preview format is NULL, defaulting to CbYCrY"); |
| pixFormat = OMX_COLOR_FormatCbYCrY; |
| } |
| |
| OMXCameraPortParameters *cap; |
| cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| |
| params.getPreviewSize(&w, &h); |
| frameRate = params.getPreviewFrameRate(); |
| params.getPreviewFpsRange(&minFramerate, &maxFramerate); |
| minFramerate /= CameraHal::VFR_SCALE; |
| maxFramerate /= CameraHal::VFR_SCALE; |
| if ( ( 0 < minFramerate ) && ( 0 < maxFramerate ) ) { |
| if ( minFramerate > maxFramerate ) { |
| CAMHAL_LOGEA(" Min FPS set higher than MAX. So setting MIN and MAX to the higher value"); |
| maxFramerate = minFramerate; |
| } |
| |
| if ( 0 >= frameRate ) { |
| frameRate = maxFramerate; |
| } |
| |
| if ( ( cap->mMinFrameRate != (OMX_U32) minFramerate ) || |
| ( cap->mMaxFrameRate != (OMX_U32) maxFramerate ) ) { |
| cap->mMinFrameRate = minFramerate; |
| cap->mMaxFrameRate = maxFramerate; |
| setVFramerate(cap->mMinFrameRate, cap->mMaxFrameRate); |
| } |
| } |
| |
| if ( 0 < frameRate ) |
| { |
| cap->mColorFormat = pixFormat; |
| cap->mWidth = w; |
| cap->mHeight = h; |
| cap->mFrameRate = frameRate; |
| |
| CAMHAL_LOGVB("Prev: cap.mColorFormat = %d", (int)cap->mColorFormat); |
| CAMHAL_LOGVB("Prev: cap.mWidth = %d", (int)cap->mWidth); |
| CAMHAL_LOGVB("Prev: cap.mHeight = %d", (int)cap->mHeight); |
| CAMHAL_LOGVB("Prev: cap.mFrameRate = %d", (int)cap->mFrameRate); |
| |
| //TODO: Add an additional parameter for video resolution |
| //use preview resolution for now |
| cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| cap->mColorFormat = pixFormat; |
| cap->mWidth = w; |
| cap->mHeight = h; |
| cap->mFrameRate = frameRate; |
| |
| CAMHAL_LOGVB("Video: cap.mColorFormat = %d", (int)cap->mColorFormat); |
| CAMHAL_LOGVB("Video: cap.mWidth = %d", (int)cap->mWidth); |
| CAMHAL_LOGVB("Video: cap.mHeight = %d", (int)cap->mHeight); |
| CAMHAL_LOGVB("Video: cap.mFrameRate = %d", (int)cap->mFrameRate); |
| |
| ///mStride is set from setBufs() while passing the APIs |
| cap->mStride = 4096; |
| cap->mBufSize = cap->mStride * cap->mHeight; |
| } |
| |
| if ( ( cap->mWidth >= 1920 ) && |
| ( cap->mHeight >= 1080 ) && |
| ( cap->mFrameRate >= FRAME_RATE_FULL_HD ) && |
| ( !mSensorOverclock ) ) |
| { |
| mOMXStateSwitch = true; |
| } |
| else if ( ( ( cap->mWidth < 1920 ) || |
| ( cap->mHeight < 1080 ) || |
| ( cap->mFrameRate < FRAME_RATE_FULL_HD ) ) && |
| ( mSensorOverclock ) ) |
| { |
| mOMXStateSwitch = true; |
| } |
| |
| #ifdef CAMERAHAL_TUNA |
| valstr = params.get(TICameraParameters::KEY_RECORDING_HINT); |
| if (!valstr || (valstr && (strcmp(valstr, android::CameraParameters::FALSE)))) { |
| mIternalRecordingHint = false; |
| } else { |
| mIternalRecordingHint = true; |
| } |
| #endif |
| |
| #ifdef OMAP_ENHANCEMENT |
| if ( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL ) |
| { |
| if (strcmp(valstr, android::CameraParameters::TRUE) == 0) |
| { |
| mMeasurementEnabled = true; |
| } |
| else if (strcmp(valstr, android::CameraParameters::FALSE) == 0) |
| { |
| mMeasurementEnabled = false; |
| } |
| else |
| { |
| mMeasurementEnabled = false; |
| } |
| } |
| else |
| { |
| //Disable measurement data by default |
| mMeasurementEnabled = false; |
| } |
| #endif |
| |
| #ifdef OMAP_ENHANCEMENT_S3D |
| setParamS3D(mCameraAdapterParameters.mPrevPortIndex, |
| params.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT)); |
| #endif |
| |
| ret |= setParametersCapture(params, state); |
| |
| ret |= setParameters3A(params, state); |
| |
| ret |= setParametersAlgo(params, state); |
| |
| ret |= setParametersFocus(params, state); |
| |
| ret |= setParametersFD(params, state); |
| |
| ret |= setParametersZoom(params, state); |
| |
| ret |= setParametersEXIF(params, state); |
| |
| mParams = params; |
| mFirstTimeInit = false; |
| |
| if ( MODE_MAX != mCapabilitiesOpMode ) { |
| mCapabilities->setMode(mCapabilitiesOpMode); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return ret; |
| } |
| |
| void saveFile(unsigned char *buff, int width, int height, int format) { |
| static int counter = 1; |
| int fd = -1; |
| char fn[256]; |
| |
| LOG_FUNCTION_NAME; |
| |
| fn[0] = 0; |
| sprintf(fn, "/preview%03d.yuv", counter); |
| fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777); |
| if(fd < 0) { |
| CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd)); |
| return; |
| } |
| |
| CAMHAL_LOGVB("Copying from 0x%x, size=%d x %d", buff, width, height); |
| |
| //method currently supports only nv12 dumping |
| int stride = width; |
| uint8_t *bf = (uint8_t*) buff; |
| for(int i=0;i<height;i++) |
| { |
| write(fd, bf, width); |
| bf += 4096; |
| } |
| |
| for(int i=0;i<height/2;i++) |
| { |
| write(fd, bf, stride); |
| bf += 4096; |
| } |
| |
| close(fd); |
| |
| |
| counter++; |
| |
| LOG_FUNCTION_NAME_EXIT; |
| } |
| |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| static status_t saveBufferToFile(const void *buf, int size, const char *filename) |
| { |
| if (size < 0) { |
| CAMHAL_LOGE("Wrong buffer size: %d", size); |
| return BAD_VALUE; |
| } |
| |
| const int fd = open(filename, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0644); |
| if (fd < 0) { |
| CAMHAL_LOGE("ERROR: %s, Unable to save raw file", strerror(fd)); |
| return BAD_VALUE; |
| } |
| |
| if (write(fd, buf, size) != (signed)size) { |
| CAMHAL_LOGE("ERROR: Unable to write to raw file: %s ", strerror(errno)); |
| close(fd); |
| return NO_MEMORY; |
| } |
| |
| CAMHAL_LOGD("buffer=%p, size=%d stored at %s", buf, size, filename); |
| |
| close(fd); |
| return OK; |
| } |
| #endif |
| |
| |
| void OMXCameraAdapter::getParameters(android::CameraParameters& params) |
| { |
| status_t ret = NO_ERROR; |
| OMX_CONFIG_EXPOSUREVALUETYPE exp; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| BaseCameraAdapter::AdapterState state; |
| BaseCameraAdapter::getState(state); |
| const char *valstr = NULL; |
| LOG_FUNCTION_NAME; |
| |
| if( mParameters3A.SceneMode != OMX_Manual ) { |
| const char *valstr_supported = NULL; |
| |
| if (mCapabilities) { |
| const SceneModesEntry* entry = NULL; |
| entry = getSceneModeEntry(mCapabilities->get(CameraProperties::CAMERA_NAME), |
| (OMX_SCENEMODETYPE) mParameters3A.SceneMode); |
| if(entry) { |
| mParameters3A.Focus = entry->focus; |
| mParameters3A.FlashMode = entry->flash; |
| mParameters3A.WhiteBallance = entry->wb; |
| } |
| } |
| |
| valstr = getLUTvalue_OMXtoHAL(mParameters3A.WhiteBallance, WBalLUT); |
| valstr_supported = mParams.get(android::CameraParameters::KEY_SUPPORTED_WHITE_BALANCE); |
| if (valstr && valstr_supported && strstr(valstr_supported, valstr)) |
| params.set(android::CameraParameters::KEY_WHITE_BALANCE , valstr); |
| |
| valstr = getLUTvalue_OMXtoHAL(mParameters3A.FlashMode, FlashLUT); |
| valstr_supported = mParams.get(android::CameraParameters::KEY_SUPPORTED_FLASH_MODES); |
| if (valstr && valstr_supported && strstr(valstr_supported, valstr)) |
| params.set(android::CameraParameters::KEY_FLASH_MODE, valstr); |
| |
| if ((mParameters3A.Focus == OMX_IMAGE_FocusControlAuto) && |
| ( (mCapMode != OMXCameraAdapter::VIDEO_MODE) && |
| (mCapMode != OMXCameraAdapter::VIDEO_MODE_HQ) ) ) { |
| valstr = android::CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; |
| } else { |
| valstr = getLUTvalue_OMXtoHAL(mParameters3A.Focus, FocusLUT); |
| } |
| valstr_supported = mParams.get(android::CameraParameters::KEY_SUPPORTED_FOCUS_MODES); |
| if (valstr && valstr_supported && strstr(valstr_supported, valstr)) |
| params.set(android::CameraParameters::KEY_FOCUS_MODE, valstr); |
| } |
| |
| //Query focus distances only when focus is running |
| if ( ( AF_ACTIVE & state ) || |
| ( NULL == mParameters.get(android::CameraParameters::KEY_FOCUS_DISTANCES) ) ) |
| { |
| updateFocusDistances(params); |
| } |
| else |
| { |
| params.set(android::CameraParameters::KEY_FOCUS_DISTANCES, |
| mParameters.get(android::CameraParameters::KEY_FOCUS_DISTANCES)); |
| } |
| |
| #ifdef OMAP_ENHANCEMENT |
| OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSUREVALUETYPE); |
| exp.nPortIndex = OMX_ALL; |
| |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &exp); |
| if ( OMX_ErrorNone == eError ) |
| { |
| params.set(TICameraParameters::KEY_CURRENT_ISO, exp.nSensitivity); |
| } |
| else |
| { |
| CAMHAL_LOGEB("OMX error 0x%x, while retrieving current ISO value", eError); |
| } |
| #endif |
| |
| { |
| android::AutoMutex lock(mZoomLock); |
| //Immediate zoom should not be avaialable while smooth zoom is running |
| if ( ZOOM_ACTIVE & state ) |
| { |
| if ( mZoomParameterIdx != mCurrentZoomIdx ) |
| { |
| mZoomParameterIdx += mZoomInc; |
| } |
| params.set(android::CameraParameters::KEY_ZOOM, mZoomParameterIdx); |
| if ( ( mCurrentZoomIdx == mTargetZoomIdx ) && |
| ( mZoomParameterIdx == mCurrentZoomIdx ) ) |
| { |
| |
| if ( NO_ERROR == ret ) |
| { |
| |
| ret = BaseCameraAdapter::setState(CAMERA_STOP_SMOOTH_ZOOM); |
| |
| if ( NO_ERROR == ret ) |
| { |
| ret = BaseCameraAdapter::commitState(); |
| } |
| else |
| { |
| ret |= BaseCameraAdapter::rollbackState(); |
| } |
| |
| } |
| |
| } |
| |
| CAMHAL_LOGDB("CameraParameters Zoom = %d", mCurrentZoomIdx); |
| } |
| else |
| { |
| params.set(android::CameraParameters::KEY_ZOOM, mCurrentZoomIdx); |
| } |
| } |
| |
| //Populate current lock status |
| if ( mUserSetExpLock || mParameters3A.ExposureLock ) { |
| params.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK, |
| android::CameraParameters::TRUE); |
| } else { |
| params.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK, |
| android::CameraParameters::FALSE); |
| } |
| |
| if ( mUserSetWbLock || mParameters3A.WhiteBalanceLock ) { |
| params.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, |
| android::CameraParameters::TRUE); |
| } else { |
| params.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, |
| android::CameraParameters::FALSE); |
| } |
| |
| // Update Picture size capabilities dynamically |
| params.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, |
| mCapabilities->get(CameraProperties::SUPPORTED_PICTURE_SIZES)); |
| |
| // Update framerate capabilities dynamically |
| params.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, |
| mCapabilities->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)); |
| |
| params.set(TICameraParameters::KEY_FRAMERATES_EXT_SUPPORTED, |
| mCapabilities->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES_EXT)); |
| |
| params.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, |
| mCapabilities->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)); |
| |
| params.set(TICameraParameters::KEY_FRAMERATE_RANGES_EXT_SUPPORTED, |
| mCapabilities->get(CameraProperties::FRAMERATE_RANGE_EXT_SUPPORTED)); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| } |
| |
| status_t OMXCameraAdapter::setupTunnel(uint32_t SliceHeight, uint32_t EncoderHandle, uint32_t width, uint32_t height) { |
| LOG_FUNCTION_NAME; |
| |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_HANDLETYPE *encoderHandle = (OMX_HANDLETYPE *)EncoderHandle; |
| |
| CAMHAL_LOGDB("\n %s: SliceHeight:%d, EncoderHandle:%d width:%d height:%d \n", __FUNCTION__, SliceHeight, EncoderHandle, width, height); |
| |
| if (SliceHeight == 0){ |
| CAMHAL_LOGEA("\n\n #### Encoder Slice Height Not received, Dont Setup Tunnel $$$$\n\n"); |
| return BAD_VALUE; |
| } |
| |
| if (encoderHandle == NULL) { |
| CAMHAL_LOGEA("Encoder Handle not set \n\n"); |
| return BAD_VALUE; |
| } |
| |
| if ( 0 != mInitSem.Count() ) { |
| CAMHAL_LOGEB("Error mInitSem semaphore count %d", mInitSem.Count()); |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_INIT; |
| } |
| |
| // Register for port enable event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| mInitSem); |
| if(ret != NO_ERROR) { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| return UNKNOWN_ERROR; |
| } |
| |
| // Enable VIDEO Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| NULL); |
| if(eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError); |
| return BAD_VALUE; |
| } |
| |
| // Wait for the port enable event to occur |
| ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| if ( NO_ERROR == ret ) { |
| CAMHAL_LOGDA("-Port enable event arrived"); |
| } else { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| NULL); |
| CAMHAL_LOGEA("Timeout for enabling preview port expired!"); |
| return UNKNOWN_ERROR; |
| } |
| |
| //Set the Video Port Params |
| OMX_PARAM_PORTDEFINITIONTYPE portCheck; |
| OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE); |
| portCheck.nPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_VIDEO; |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexParamPortDefinition, &portCheck); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_GetParameter OMX_IndexParamPortDefinition Error - %x", eError); |
| } |
| |
| portCheck.format.video.nFrameWidth = width; |
| portCheck.format.video.nFrameHeight = height; |
| portCheck.format.video.eColorFormat = OMX_COLOR_FormatYUV420PackedSemiPlanar; |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexParamPortDefinition, &portCheck); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SetParameter OMX_IndexParamPortDefinition Error- %x", eError); |
| } |
| |
| //Slice Configuration |
| OMX_TI_PARAM_VTCSLICE VTCSlice; |
| OMX_INIT_STRUCT_PTR(&VTCSlice, OMX_TI_PARAM_VTCSLICE); |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_TI_IndexParamVtcSlice, &VTCSlice); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_GetParameter OMX_TI_IndexParamVtcSlice Error - %x", eError); |
| } |
| |
| VTCSlice.nSliceHeight = SliceHeight; |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_TI_IndexParamVtcSlice, &VTCSlice); |
| if (OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("OMX_SetParameter on OMX_TI_IndexParamVtcSlice returned error: 0x%x", eError); |
| return BAD_VALUE; |
| } |
| |
| eError = OMX_SetupTunnel(mCameraAdapterParameters.mHandleComp, |
| mCameraAdapterParameters.mVideoPortIndex, encoderHandle, 0); |
| if (OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("OMX_SetupTunnel returned error: 0x%x", eError); |
| return BAD_VALUE; |
| } |
| |
| return NO_ERROR; |
| } |
| |
| status_t OMXCameraAdapter::setSensorQuirks(int orientation, |
| OMXCameraPortParameters &portParams, |
| bool &portConfigured) |
| { |
| status_t overclockStatus = NO_ERROR; |
| int sensorID = -1; |
| size_t overclockWidth; |
| size_t overclockHeight; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_PARAM_PORTDEFINITIONTYPE portCheck; |
| |
| LOG_FUNCTION_NAME; |
| |
| portConfigured = false; |
| OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE); |
| |
| portCheck.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp, |
| OMX_IndexParamPortDefinition, |
| &portCheck); |
| |
| if ( eError != OMX_ErrorNone ) { |
| CAMHAL_LOGEB("OMX_GetParameter - %x", eError); |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| if ( ( orientation == 90 ) || ( orientation == 270 ) ) { |
| overclockWidth = 1080; |
| overclockHeight = 1920; |
| } else { |
| overclockWidth = 1920; |
| overclockHeight = 1080; |
| } |
| |
| sensorID = mCapabilities->getInt(CameraProperties::CAMERA_SENSOR_ID); |
| if( ( ( sensorID == SENSORID_IMX060 ) && |
| ( portParams.mWidth >= overclockWidth ) && |
| ( portParams.mHeight >= overclockHeight ) && |
| ( portParams.mFrameRate >= FRAME_RATE_FULL_HD ) ) || |
| (( sensorID == SENSORID_OV14825) && |
| ( portParams.mFrameRate >= FRAME_RATE_HIGH_HD ))|| |
| ( ( sensorID == SENSORID_OV5640 ) && |
| ( portParams.mWidth >= overclockWidth ) && |
| ( portParams.mHeight >= overclockHeight ) ) ) { |
| overclockStatus = setSensorOverclock(true); |
| } else { |
| |
| //WA: If the next port resolution doesn't require |
| // sensor overclocking, but the previous resolution |
| // needed it, then we have to first set new port |
| // resolution and then disable sensor overclocking. |
| if( ( ( sensorID == SENSORID_IMX060 ) && |
| ( portCheck.format.video.nFrameWidth >= overclockWidth ) && |
| ( portCheck.format.video.nFrameHeight >= overclockHeight ) && |
| ( ( portCheck.format.video.xFramerate >> 16 ) >= FRAME_RATE_FULL_HD ) ) || |
| (( sensorID == SENSORID_OV14825) && |
| (( portCheck.format.video.xFramerate >> 16) >= FRAME_RATE_HIGH_HD ))|| |
| ( ( sensorID == SENSORID_OV5640 ) && |
| ( portCheck.format.video.nFrameWidth >= overclockWidth ) && |
| ( portCheck.format.video.nFrameHeight >= overclockHeight ) ) ) { |
| status_t ret = setFormat(mCameraAdapterParameters.mPrevPortIndex, |
| portParams); |
| if ( NO_ERROR != ret ) { |
| return ret; |
| } |
| |
| // Another WA: Setting the port definition will reset the VFR |
| // configuration. |
| setVFramerate(portParams.mMinFrameRate, portParams.mMaxFrameRate); |
| |
| portConfigured = true; |
| } |
| |
| overclockStatus = setSensorOverclock(false); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return overclockStatus; |
| } |
| status_t OMXCameraAdapter::setFormat(OMX_U32 port, OMXCameraPortParameters &portParams) |
| { |
| LOG_FUNCTION_NAME; |
| |
| status_t ret = NO_ERROR; |
| size_t bufferCount; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_PARAM_PORTDEFINITIONTYPE portCheck; |
| |
| OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE); |
| |
| portCheck.nPortIndex = port; |
| |
| eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp, |
| OMX_IndexParamPortDefinition, &portCheck); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_GetParameter - %x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| if (OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW == port) { |
| portCheck.format.video.nFrameWidth = portParams.mWidth; |
| portCheck.format.video.nFrameHeight = portParams.mHeight; |
| portCheck.format.video.eColorFormat = portParams.mColorFormat; |
| portCheck.format.video.nStride = portParams.mStride; |
| |
| portCheck.format.video.xFramerate = portParams.mFrameRate<<16; |
| portCheck.nBufferSize = portParams.mStride * portParams.mHeight; |
| portCheck.nBufferCountActual = portParams.mNumBufs; |
| mFocusThreshold = FOCUS_THRESHOLD * portParams.mFrameRate; |
| // Used for RAW capture |
| } else if (OMX_CAMERA_PORT_VIDEO_OUT_VIDEO == port) { |
| portCheck.format.video.nFrameWidth = portParams.mWidth; |
| portCheck.format.video.nFrameHeight = portParams.mHeight; |
| portCheck.format.video.eColorFormat = OMX_COLOR_FormatRawBayer10bit; // portParams.mColorFormat; |
| portCheck.nBufferCountActual = 1; // portParams.mNumBufs; |
| } else if (OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port) { |
| portCheck.format.image.nFrameWidth = portParams.mWidth; |
| portCheck.format.image.nFrameHeight = portParams.mHeight; |
| if (OMX_COLOR_FormatUnused == portParams.mColorFormat) { |
| portCheck.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; |
| if (mCodingMode == CodingJPEG) { |
| portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG; |
| } else if (mCodingMode == CodingJPS) { |
| portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingJPS; |
| } else if (mCodingMode == CodingMPO) { |
| portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingMPO; |
| } else { |
| portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused; |
| } |
| } else { |
| portCheck.format.image.eColorFormat = portParams.mColorFormat; |
| portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused; |
| } |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| // RAW + YUV Capture |
| if (mYuvCapture) { |
| portCheck.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; |
| portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused; |
| } |
| #endif |
| //Stride for 1D tiler buffer is zero |
| portCheck.format.image.nStride = 0; |
| portCheck.nBufferCountActual = portParams.mNumBufs; |
| } else if (OMX_CAMERA_PORT_VIDEO_IN_VIDEO == port) { |
| portCheck.format.video.nFrameWidth = portParams.mWidth; |
| portCheck.format.video.nStride = portParams.mStride; |
| portCheck.format.video.nFrameHeight = portParams.mHeight; |
| portCheck.format.video.eColorFormat = portParams.mColorFormat; |
| portCheck.format.video.xFramerate = 30 << 16; |
| portCheck.nBufferCountActual = portParams.mNumBufs; |
| } else { |
| CAMHAL_LOGEB("Unsupported port index (%lu)", port); |
| } |
| |
| if (( mSensorIndex == OMX_TI_StereoSensor ) && (OMX_CAMERA_PORT_VIDEO_OUT_VIDEO != port)) { |
| ret = setS3DFrameLayout(port); |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEA("Error configuring stereo 3D frame layout"); |
| return ret; |
| } |
| } |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexParamPortDefinition, &portCheck); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SetParameter - %x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| /* check if parameters are set correctly by calling GetParameter() */ |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexParamPortDefinition, &portCheck); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_GetParameter - %x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| portParams.mBufSize = portCheck.nBufferSize; |
| portParams.mStride = portCheck.format.image.nStride; |
| |
| if (OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port) { |
| CAMHAL_LOGDB("\n *** IMG Width = %ld", portCheck.format.image.nFrameWidth); |
| CAMHAL_LOGDB("\n *** IMG Height = %ld", portCheck.format.image.nFrameHeight); |
| |
| CAMHAL_LOGDB("\n *** IMG IMG FMT = %x", portCheck.format.image.eColorFormat); |
| CAMHAL_LOGDB("\n *** IMG portCheck.nBufferSize = %ld\n",portCheck.nBufferSize); |
| CAMHAL_LOGDB("\n *** IMG portCheck.nBufferCountMin = %ld\n", |
| portCheck.nBufferCountMin); |
| CAMHAL_LOGDB("\n *** IMG portCheck.nBufferCountActual = %ld\n", |
| portCheck.nBufferCountActual); |
| CAMHAL_LOGDB("\n *** IMG portCheck.format.image.nStride = %ld\n", |
| portCheck.format.image.nStride); |
| } else if (OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW == port) { |
| CAMHAL_LOGDB("\n *** PRV Width = %ld", portCheck.format.video.nFrameWidth); |
| CAMHAL_LOGDB("\n *** PRV Height = %ld", portCheck.format.video.nFrameHeight); |
| |
| CAMHAL_LOGDB("\n *** PRV IMG FMT = %x", portCheck.format.video.eColorFormat); |
| CAMHAL_LOGDB("\n *** PRV portCheck.nBufferSize = %ld\n",portCheck.nBufferSize); |
| CAMHAL_LOGDB("\n *** PRV portCheck.nBufferCountMin = %ld\n", |
| portCheck.nBufferCountMin); |
| CAMHAL_LOGDB("\n *** PRV portCheck.nBufferCountActual = %ld\n", |
| portCheck.nBufferCountActual); |
| CAMHAL_LOGDB("\n ***PRV portCheck.format.video.nStride = %ld\n", |
| portCheck.format.video.nStride); |
| } else { |
| CAMHAL_LOGDB("\n *** VID Width = %ld", portCheck.format.video.nFrameWidth); |
| CAMHAL_LOGDB("\n *** VID Height = %ld", portCheck.format.video.nFrameHeight); |
| |
| CAMHAL_LOGDB("\n *** VID IMG FMT = %x", portCheck.format.video.eColorFormat); |
| CAMHAL_LOGDB("\n *** VID portCheck.nBufferSize = %ld\n",portCheck.nBufferSize); |
| CAMHAL_LOGDB("\n *** VID portCheck.nBufferCountMin = %ld\n", |
| portCheck.nBufferCountMin); |
| CAMHAL_LOGDB("\n *** VID portCheck.nBufferCountActual = %ld\n", |
| portCheck.nBufferCountActual); |
| CAMHAL_LOGDB("\n *** VID portCheck.format.video.nStride = %ld\n", |
| portCheck.format.video.nStride); |
| } |
| |
| mSetFormatDone = true; |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| |
| EXIT: |
| |
| CAMHAL_LOGEB("Exiting function %s because of eError = 0x%x", __FUNCTION__, eError); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::flushBuffers(OMX_U32 nPort) |
| { |
| LOG_FUNCTION_NAME; |
| |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| if ( 0 != mFlushSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mFlushSem semaphore count %d", mFlushSem.Count()); |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_INIT; |
| } |
| |
| OMXCameraPortParameters * mPreviewData = NULL; |
| mPreviewData = &mCameraAdapterParameters.mCameraPortParams[nPort]; |
| |
| ///Register for the FLUSH event |
| ///This method just inserts a message in Event Q, which is checked in the callback |
| ///The sempahore passed is signalled by the callback |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandFlush, |
| nPort, |
| mFlushSem); |
| if(ret!=NO_ERROR) |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| ///Send FLUSH command to preview port |
| eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp, |
| OMX_CommandFlush, |
| nPort, |
| NULL); |
| |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandFlush)-0x%x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| CAMHAL_LOGDA("Waiting for flush event"); |
| |
| ///Wait for the FLUSH event to occur |
| ret = mFlushSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after Flush Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("Flush event received"); |
| } |
| else |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandFlush, |
| nPort, |
| NULL); |
| CAMHAL_LOGDA("Flush event timeout expired"); |
| goto EXIT; |
| } |
| |
| mOMXCallbackHandler->flush(); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| ///API to give the buffers to Adapter |
| status_t OMXCameraAdapter::useBuffers(CameraMode mode, CameraBuffer * bufArr, int num, size_t length, unsigned int queueable) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| status_t ret = NO_ERROR; |
| |
| LOG_FUNCTION_NAME; |
| |
| switch(mode) |
| { |
| case CAMERA_PREVIEW: |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs = num; |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable; |
| ret = UseBuffersPreview(bufArr, num); |
| break; |
| |
| case CAMERA_IMAGE_CAPTURE: |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mMaxQueueable = queueable; |
| ret = UseBuffersCapture(bufArr, num); |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mNumBufs = num; |
| break; |
| |
| case CAMERA_VIDEO: |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex].mNumBufs = num; |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex].mMaxQueueable = queueable; |
| ret = UseBuffersRawCapture(bufArr, num); |
| break; |
| |
| case CAMERA_MEASUREMENT: |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mNumBufs = num; |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mMaxQueueable = queueable; |
| ret = UseBuffersPreviewData(bufArr, num); |
| break; |
| |
| case CAMERA_REPROCESS: |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoInPortIndex].mNumBufs = num; |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoInPortIndex].mMaxQueueable = queueable; |
| ret = UseBuffersReprocess(bufArr, num); |
| break; |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::UseBuffersPreviewData(CameraBuffer * bufArr, int num) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMXCameraPortParameters * measurementData = NULL; |
| android::AutoMutex lock(mPreviewDataBufferLock); |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( mComponentState != OMX_StateLoaded ) |
| { |
| CAMHAL_LOGEA("Calling UseBuffersPreviewData() when not in LOADED state"); |
| return BAD_VALUE; |
| } |
| |
| if ( NULL == bufArr ) |
| { |
| CAMHAL_LOGEA("NULL pointer passed for buffArr"); |
| return BAD_VALUE; |
| } |
| |
| if ( 0 != mUsePreviewDataSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mUsePreviewDataSem semaphore count %d", mUsePreviewDataSem.Count()); |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_INIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; |
| measurementData->mNumBufs = num ; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| ///Register for port enable event on measurement port |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mMeasurementPortIndex, |
| mUsePreviewDataSem); |
| |
| if ( ret == NO_ERROR ) |
| { |
| CAMHAL_LOGDB("Registering for event %d", ret); |
| } |
| else |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| ///Enable MEASUREMENT Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mMeasurementPortIndex, |
| NULL); |
| |
| if ( eError == OMX_ErrorNone ) |
| { |
| CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError); |
| goto EXIT; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| ret = mUsePreviewDataSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after measurement port enable Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("Port enable event arrived on measurement port"); |
| } |
| else |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mMeasurementPortIndex, |
| NULL); |
| CAMHAL_LOGEA("Timeout expoired during port enable on measurement port"); |
| goto EXIT; |
| } |
| |
| CAMHAL_LOGDA("Port enable event arrived on measurement port"); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::switchToExecuting() |
| { |
| status_t ret = NO_ERROR; |
| Utils::Message msg; |
| |
| LOG_FUNCTION_NAME; |
| |
| mStateSwitchLock.lock(); |
| msg.command = CommandHandler::CAMERA_SWITCH_TO_EXECUTING; |
| msg.arg1 = mErrorNotifier; |
| ret = mCommandHandler->put(&msg); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::doSwitchToExecuting() |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| LOG_FUNCTION_NAME; |
| |
| if ( (mComponentState == OMX_StateExecuting) || (mComponentState == OMX_StateInvalid) ){ |
| CAMHAL_LOGDA("Already in OMX_Executing state or OMX_StateInvalid state"); |
| mStateSwitchLock.unlock(); |
| return NO_ERROR; |
| } |
| |
| if ( 0 != mSwitchToExecSem.Count() ){ |
| CAMHAL_LOGEB("Error mSwitchToExecSem semaphore count %d", mSwitchToExecSem.Count()); |
| goto EXIT; |
| } |
| |
| ///Register for Preview port DISABLE event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| mSwitchToExecSem); |
| if ( NO_ERROR != ret ){ |
| CAMHAL_LOGEB("Error in registering Port Disable for event %d", ret); |
| goto EXIT; |
| } |
| ///Disable Preview Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| NULL); |
| ret = mSwitchToExecSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| if (ret != NO_ERROR){ |
| CAMHAL_LOGEB("Timeout PREVIEW PORT DISABLE %d", ret); |
| } |
| |
| CAMHAL_LOGVB("PREV PORT DISABLED %d", ret); |
| |
| ///Register for IDLE state switch event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| mSwitchToExecSem); |
| if(ret!=NO_ERROR) |
| { |
| CAMHAL_LOGEB("Error in IDLE STATE SWITCH %d", ret); |
| goto EXIT; |
| } |
| eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp , |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| NULL); |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| ret = mSwitchToExecSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| if (ret != NO_ERROR){ |
| CAMHAL_LOGEB("Timeout IDLE STATE SWITCH %d", ret); |
| goto EXIT; |
| } |
| mComponentState = OMX_StateIdle; |
| CAMHAL_LOGVB("OMX_SendCommand(OMX_StateIdle) 0x%x", eError); |
| |
| ///Register for EXECUTING state switch event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateExecuting, |
| mSwitchToExecSem); |
| if(ret!=NO_ERROR) |
| { |
| CAMHAL_LOGEB("Error in EXECUTING STATE SWITCH %d", ret); |
| goto EXIT; |
| } |
| eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp , |
| OMX_CommandStateSet, |
| OMX_StateExecuting, |
| NULL); |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| ret = mSwitchToExecSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| if (ret != NO_ERROR){ |
| CAMHAL_LOGEB("Timeout EXEC STATE SWITCH %d", ret); |
| goto EXIT; |
| } |
| mComponentState = OMX_StateExecuting; |
| CAMHAL_LOGVB("OMX_SendCommand(OMX_StateExecuting) 0x%x", eError); |
| |
| mStateSwitchLock.unlock(); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return ret; |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| mStateSwitchLock.unlock(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::switchToIdle() { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex lock(mIdleStateSwitchLock); |
| |
| if ( mComponentState == OMX_StateIdle || mComponentState == OMX_StateLoaded || mComponentState == OMX_StateInvalid) { |
| CAMHAL_LOGDA("Already in OMX_StateIdle, OMX_Loaded state or OMX_StateInvalid state"); |
| return NO_ERROR; |
| } |
| |
| if ( 0 != mSwitchToLoadedSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mSwitchToLoadedSem semaphore count %d", mSwitchToLoadedSem.Count()); |
| goto EXIT; |
| } |
| |
| ///Register for EXECUTING state transition. |
| ///This method just inserts a message in Event Q, which is checked in the callback |
| ///The sempahore passed is signalled by the callback |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| mSwitchToLoadedSem); |
| |
| if(ret!=NO_ERROR) |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp, |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| NULL); |
| |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_StateIdle) - %x", eError); |
| } |
| |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| ///Wait for the EXECUTING ->IDLE transition to arrive |
| |
| CAMHAL_LOGDA("EXECUTING->IDLE state changed"); |
| ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after EXECUTING->IDLE Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("EXECUTING->IDLE state changed"); |
| } |
| else |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| NULL); |
| CAMHAL_LOGEA("Timeout expired on EXECUTING->IDLE state change"); |
| goto EXIT; |
| } |
| |
| mComponentState = OMX_StateIdle; |
| |
| return NO_ERROR; |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| |
| |
| status_t OMXCameraAdapter::prevPortEnable() { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| LOG_FUNCTION_NAME; |
| |
| ///Register for Preview port ENABLE event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| mSwitchToLoadedSem); |
| |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| ///Enable Preview Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| NULL); |
| |
| |
| CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError); |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| CAMHAL_LOGDA("Enabling Preview port"); |
| ///Wait for state to switch to idle |
| ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after Enabling Preview port Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("Preview port enabled!"); |
| } |
| else |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| NULL); |
| CAMHAL_LOGEA("Preview enable timedout"); |
| |
| goto EXIT; |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::switchToLoaded(bool bPortEnableRequired) { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex lock(mStateSwitchLock); |
| if ( mComponentState == OMX_StateLoaded || mComponentState == OMX_StateInvalid) { |
| CAMHAL_LOGDA("Already in OMX_Loaded state or OMX_StateInvalid state"); |
| return NO_ERROR; |
| } |
| |
| if ( mComponentState != OMX_StateIdle) { |
| ret = switchToIdle(); |
| if (ret != NO_ERROR) return ret; |
| } |
| |
| if ( 0 != mSwitchToLoadedSem.Count() ) { |
| CAMHAL_LOGEB("Error mSwitchToLoadedSem semaphore count %d", mSwitchToLoadedSem.Count()); |
| goto EXIT; |
| } |
| |
| ///Register for LOADED state transition. |
| ///This method just inserts a message in Event Q, which is checked in the callback |
| ///The sempahore passed is signalled by the callback |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateLoaded, |
| mSwitchToLoadedSem); |
| |
| if(ret!=NO_ERROR) |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp, |
| OMX_CommandStateSet, |
| OMX_StateLoaded, |
| NULL); |
| |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_StateLoaded) - %x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| if ( !bPortEnableRequired ) { |
| OMXCameraPortParameters *mCaptureData , *mPreviewData, *measurementData; |
| mCaptureData = mPreviewData = measurementData = NULL; |
| |
| mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| mCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; |
| |
| ///Free the OMX Buffers |
| for ( int i = 0 ; i < mPreviewData->mNumBufs ; i++ ) { |
| eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp, |
| mCameraAdapterParameters.mPrevPortIndex, |
| mPreviewData->mBufferHeader[i]); |
| |
| if(eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| |
| if ( mMeasurementEnabled ) { |
| |
| for ( int i = 0 ; i < measurementData->mNumBufs ; i++ ) { |
| eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp, |
| mCameraAdapterParameters.mMeasurementPortIndex, |
| measurementData->mBufferHeader[i]); |
| if(eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| |
| { |
| android::AutoMutex lock(mPreviewDataBufferLock); |
| mPreviewDataBuffersAvailable.clear(); |
| } |
| |
| } |
| } |
| |
| CAMHAL_LOGDA("Switching IDLE->LOADED state"); |
| ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after IDLE->LOADED Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("IDLE->LOADED state changed"); |
| } |
| else |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateLoaded, |
| NULL); |
| CAMHAL_LOGEA("Timeout expired on IDLE->LOADED state change"); |
| goto EXIT; |
| } |
| |
| mComponentState = OMX_StateLoaded; |
| if (bPortEnableRequired == true) { |
| prevPortEnable(); |
| } |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| { |
| android::AutoMutex lock(mPreviewBufferLock); |
| ///Clear all the available preview buffers |
| mPreviewBuffersAvailable.clear(); |
| } |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::UseBuffersPreview(CameraBuffer * bufArr, int num) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| int tmpHeight, tmpWidth; |
| |
| LOG_FUNCTION_NAME; |
| |
| if(!bufArr) |
| { |
| CAMHAL_LOGEA("NULL pointer passed for buffArr"); |
| LOG_FUNCTION_NAME_EXIT; |
| return BAD_VALUE; |
| } |
| |
| OMXCameraPortParameters * mPreviewData = NULL; |
| OMXCameraPortParameters *measurementData = NULL; |
| mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; |
| mPreviewData->mNumBufs = num ; |
| |
| if ( 0 != mUsePreviewSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mUsePreviewSem semaphore count %d", mUsePreviewSem.Count()); |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_INIT; |
| } |
| |
| if(mPreviewData->mNumBufs != num) |
| { |
| CAMHAL_LOGEA("Current number of buffers doesnt equal new num of buffers passed!"); |
| LOG_FUNCTION_NAME_EXIT; |
| return BAD_VALUE; |
| } |
| |
| mStateSwitchLock.lock(); |
| |
| if ( mComponentState == OMX_StateLoaded ) { |
| |
| if (mPendingPreviewSettings & SetLDC) { |
| mPendingPreviewSettings &= ~SetLDC; |
| ret = setLDC(mIPP); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("setLDC() failed %d", ret); |
| } |
| } |
| |
| if (mPendingPreviewSettings & SetNSF) { |
| mPendingPreviewSettings &= ~SetNSF; |
| ret = setNSF(mIPP); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("setNSF() failed %d", ret); |
| } |
| } |
| |
| if (mPendingPreviewSettings & SetCapMode) { |
| mPendingPreviewSettings &= ~SetCapMode; |
| ret = setCaptureMode(mCapMode); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("setCaptureMode() failed %d", ret); |
| } |
| } |
| |
| if( (mCapMode == OMXCameraAdapter::VIDEO_MODE) || |
| (mCapMode == OMXCameraAdapter::VIDEO_MODE_HQ) ) { |
| |
| if (mPendingPreviewSettings & SetVNF) { |
| mPendingPreviewSettings &= ~SetVNF; |
| ret = enableVideoNoiseFilter(mVnfEnabled); |
| if ( NO_ERROR != ret){ |
| CAMHAL_LOGEB("Error configuring VNF %x", ret); |
| } |
| } |
| |
| if (mPendingPreviewSettings & SetVSTAB) { |
| mPendingPreviewSettings &= ~SetVSTAB; |
| ret = enableVideoStabilization(mVstabEnabled); |
| if ( NO_ERROR != ret) { |
| CAMHAL_LOGEB("Error configuring VSTAB %x", ret); |
| } |
| } |
| |
| } |
| } |
| |
| ret = setSensorOrientation(mSensorOrientation); |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret); |
| mSensorOrientation = 0; |
| } |
| |
| if ( mComponentState == OMX_StateLoaded ) |
| { |
| ///Register for IDLE state switch event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| mUsePreviewSem); |
| |
| if(ret!=NO_ERROR) |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| ///Once we get the buffers, move component state to idle state and pass the buffers to OMX comp using UseBuffer |
| eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp , |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| NULL); |
| |
| CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError); |
| |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| mComponentState = OMX_StateIdle; |
| } |
| else |
| { |
| ///Register for Preview port ENABLE event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| mUsePreviewSem); |
| |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| ///Enable Preview Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| NULL); |
| } |
| |
| |
| ///Configure DOMX to use either gralloc handles or vptrs |
| OMX_TI_PARAMUSENATIVEBUFFER domxUseGrallocHandles; |
| OMX_INIT_STRUCT_PTR (&domxUseGrallocHandles, OMX_TI_PARAMUSENATIVEBUFFER); |
| |
| domxUseGrallocHandles.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| domxUseGrallocHandles.bEnable = OMX_TRUE; |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexUseNativeBuffers, &domxUseGrallocHandles); |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_SetParameter - %x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| OMX_BUFFERHEADERTYPE *pBufferHdr; |
| for(int index=0;index<num;index++) { |
| OMX_U8 *ptr; |
| |
| ptr = (OMX_U8 *)camera_buffer_get_omx_ptr (&bufArr[index]); |
| eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp, |
| &pBufferHdr, |
| mCameraAdapterParameters.mPrevPortIndex, |
| 0, |
| mPreviewData->mBufSize, |
| ptr); |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_UseBuffer-0x%x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| pBufferHdr->pAppPrivate = (OMX_PTR)&bufArr[index]; |
| pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE); |
| pBufferHdr->nVersion.s.nVersionMajor = 1 ; |
| pBufferHdr->nVersion.s.nVersionMinor = 1 ; |
| pBufferHdr->nVersion.s.nRevision = 0 ; |
| pBufferHdr->nVersion.s.nStep = 0; |
| mPreviewData->mBufferHeader[index] = pBufferHdr; |
| } |
| |
| if ( mMeasurementEnabled ) |
| { |
| |
| for( int i = 0; i < num; i++ ) |
| { |
| OMX_BUFFERHEADERTYPE *pBufHdr; |
| OMX_U8 *ptr; |
| |
| ptr = (OMX_U8 *)camera_buffer_get_omx_ptr (&mPreviewDataBuffers[i]); |
| eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp, |
| &pBufHdr, |
| mCameraAdapterParameters.mMeasurementPortIndex, |
| 0, |
| measurementData->mBufSize, |
| ptr); |
| |
| if ( eError == OMX_ErrorNone ) |
| { |
| pBufHdr->pAppPrivate = (OMX_PTR *)&mPreviewDataBuffers[i]; |
| pBufHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE); |
| pBufHdr->nVersion.s.nVersionMajor = 1 ; |
| pBufHdr->nVersion.s.nVersionMinor = 1 ; |
| pBufHdr->nVersion.s.nRevision = 0 ; |
| pBufHdr->nVersion.s.nStep = 0; |
| measurementData->mBufferHeader[i] = pBufHdr; |
| } |
| else |
| { |
| CAMHAL_LOGEB("OMX_UseBuffer -0x%x", eError); |
| ret = BAD_VALUE; |
| break; |
| } |
| } |
| |
| } |
| |
| CAMHAL_LOGDA("Registering preview buffers"); |
| |
| ret = mUsePreviewSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after Registering preview buffers Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("Preview buffer registration successfull"); |
| } |
| else |
| { |
| if ( mComponentState == OMX_StateLoaded ) |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateIdle, |
| NULL); |
| } |
| else |
| { |
| ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mPrevPortIndex, |
| NULL); |
| } |
| CAMHAL_LOGEA("Timeout expired on preview buffer registration"); |
| goto EXIT; |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| ///If there is any failure, we reach here. |
| ///Here, we do any resource freeing and convert from OMX error code to Camera Hal error code |
| EXIT: |
| mStateSwitchLock.unlock(); |
| |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::startPreview() |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMXCameraPortParameters *mPreviewData = NULL; |
| OMXCameraPortParameters *measurementData = NULL; |
| |
| LOG_FUNCTION_NAME; |
| |
| if( 0 != mStartPreviewSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mStartPreviewSem semaphore count %d", mStartPreviewSem.Count()); |
| ret = NO_INIT; |
| goto EXIT; |
| } |
| |
| // Enable all preview mode extra data. |
| if ( OMX_ErrorNone == eError) { |
| ret |= setExtraData(true, mCameraAdapterParameters.mPrevPortIndex, OMX_AncillaryData); |
| ret |= setExtraData(true, OMX_ALL, OMX_TI_VectShotInfo); |
| } |
| |
| mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; |
| |
| if( OMX_StateIdle == mComponentState ) |
| { |
| ///Register for EXECUTING state transition. |
| ///This method just inserts a message in Event Q, which is checked in the callback |
| ///The sempahore passed is signalled by the callback |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateExecuting, |
| mStartPreviewSem); |
| |
| if(ret!=NO_ERROR) |
| { |
| CAMHAL_LOGEB("Error in registering for event %d", ret); |
| goto EXIT; |
| } |
| |
| ///Switch to EXECUTING state |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandStateSet, |
| OMX_StateExecuting, |
| NULL); |
| |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_SendCommand(OMX_StateExecuting)-0x%x", eError); |
| } |
| |
| CAMHAL_LOGDA("+Waiting for component to go into EXECUTING state"); |
| ret = mStartPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after IDLE_EXECUTING Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("+Great. Component went into executing state!!"); |
| } |
| else |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandStateSet, |
| OMX_StateExecuting, |
| NULL); |
| CAMHAL_LOGDA("Timeout expired on executing state switch!"); |
| goto EXIT; |
| } |
| |
| mComponentState = OMX_StateExecuting; |
| |
| } |
| |
| mStateSwitchLock.unlock(); |
| |
| //Queue all the buffers on preview port |
| for(int index=0;index< mPreviewData->mMaxQueueable;index++) |
| { |
| CAMHAL_LOGDB("Queuing buffer on Preview port - 0x%x", (uint32_t)mPreviewData->mBufferHeader[index]->pBuffer); |
| mPreviewData->mStatus[index] = OMXCameraPortParameters::FILL; |
| eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, |
| (OMX_BUFFERHEADERTYPE*)mPreviewData->mBufferHeader[index]); |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError); |
| } |
| mFramesWithDucati++; |
| #ifdef CAMERAHAL_DEBUG |
| mBuffersWithDucati.add((int)mPreviewData->mBufferHeader[index]->pBuffer,1); |
| #endif |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| |
| if ( mMeasurementEnabled ) |
| { |
| |
| for(int index=0;index< mPreviewData->mNumBufs;index++) |
| { |
| CAMHAL_LOGDB("Queuing buffer on Measurement port - 0x%x", (uint32_t) measurementData->mBufferHeader[index]->pBuffer); |
| measurementData->mStatus[index] = OMXCameraPortParameters::FILL; |
| eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, |
| (OMX_BUFFERHEADERTYPE*) measurementData->mBufferHeader[index]); |
| if(eError!=OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError); |
| } |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| |
| } |
| |
| setFocusCallback(true); |
| |
| //reset frame rate estimates |
| mFPS = 0.0f; |
| mLastFPS = 0.0f; |
| // start frame count from 0. i.e first frame after |
| // startPreview will be the 0th reference frame |
| // this way we will wait for second frame until |
| // takePicture/autoFocus is allowed to run. we |
| // are seeing SetConfig/GetConfig fail after |
| // calling after the first frame and not failing |
| // after the second frame |
| mFrameCount = -1; |
| mLastFrameCount = 0; |
| mIter = 1; |
| mLastFPSTime = systemTime(); |
| mTunnelDestroyed = false; |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| performCleanupAfterError(); |
| mStateSwitchLock.unlock(); |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| } |
| |
| status_t OMXCameraAdapter::destroyTunnel() |
| { |
| LOG_FUNCTION_NAME; |
| |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| status_t ret = NO_ERROR; |
| |
| OMXCameraPortParameters *mCaptureData , *mPreviewData, *measurementData; |
| mCaptureData = mPreviewData = measurementData = NULL; |
| |
| mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| mCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; |
| |
| if (mAdapterState == LOADED_PREVIEW_STATE) { |
| // Something happened in CameraHal between UseBuffers and startPreview |
| // this means that state switch is still locked..so we need to unlock else |
| // deadlock will occur on the next start preview |
| mStateSwitchLock.unlock(); |
| return ALREADY_EXISTS; |
| } |
| |
| if ( mComponentState != OMX_StateExecuting ) |
| { |
| CAMHAL_LOGEA("Calling StopPreview() when not in EXECUTING state"); |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_INIT; |
| } |
| |
| { |
| android::AutoMutex lock(mFrameCountMutex); |
| // we should wait for the first frame to come before trying to stopPreview...if not |
| // we might put OMXCamera in a bad state (IDLE->LOADED timeout). Seeing this a lot |
| // after a capture |
| if (mFrameCount < 1) { |
| // I want to wait for at least two frames.... |
| mFrameCount = -1; |
| |
| // first frame may time some time to come...so wait for an adequate amount of time |
| // which 2 * OMX_CAPTURE_TIMEOUT * 1000 will cover. |
| ret = mFirstFrameCondition.waitRelative(mFrameCountMutex, |
| (nsecs_t) 2 * OMX_CAPTURE_TIMEOUT * 1000); |
| } |
| // even if we timeout waiting for the first frame...go ahead with trying to stop preview |
| // signal anybody that might be waiting |
| mFrameCount = 0; |
| mFirstFrameCondition.broadcast(); |
| } |
| |
| { |
| android::AutoMutex lock(mDoAFMutex); |
| mDoAFCond.broadcast(); |
| } |
| |
| OMX_CONFIG_FOCUSASSISTTYPE focusAssist; |
| OMX_INIT_STRUCT_PTR (&focusAssist, OMX_CONFIG_FOCUSASSISTTYPE); |
| focusAssist.nPortIndex = OMX_ALL; |
| focusAssist.bFocusAssist = OMX_FALSE; |
| CAMHAL_LOGDB("Configuring AF Assist mode 0x%x", focusAssist.bFocusAssist); |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_IndexConfigFocusAssist, |
| &focusAssist); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring AF Assist mode 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Camera AF Assist mode configured successfully"); |
| } |
| |
| if ( 0 != mStopPreviewSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mStopPreviewSem semaphore count %d", mStopPreviewSem.Count()); |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_INIT; |
| } |
| |
| ret = disableImagePort(); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("disable image port failed 0x%x", ret); |
| goto EXIT; |
| } |
| |
| CAMHAL_LOGDB("Average framerate: %f", mFPS); |
| |
| //Avoid state switching of the OMX Component |
| ret = flushBuffers(); |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEB("Flush Buffers failed 0x%x", ret); |
| goto EXIT; |
| } |
| |
| switchToIdle(); |
| |
| mTunnelDestroyed = true; |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| { |
| android::AutoMutex lock(mPreviewBufferLock); |
| ///Clear all the available preview buffers |
| mPreviewBuffersAvailable.clear(); |
| } |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| } |
| |
| status_t OMXCameraAdapter::stopPreview() { |
| LOG_FUNCTION_NAME; |
| |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| status_t ret = NO_ERROR; |
| |
| if (mTunnelDestroyed == false){ |
| ret = destroyTunnel(); |
| if (ret == ALREADY_EXISTS) { |
| // Special case to handle invalid stopping preview in LOADED_PREVIEW_STATE |
| return NO_ERROR; |
| } |
| if (ret != NO_ERROR) { |
| CAMHAL_LOGEB(" destroyTunnel returned error "); |
| return ret; |
| } |
| } |
| |
| mTunnelDestroyed = false; |
| |
| { |
| android::AutoMutex lock(mPreviewBufferLock); |
| ///Clear all the available preview buffers |
| mPreviewBuffersAvailable.clear(); |
| } |
| |
| switchToLoaded(); |
| |
| mFirstTimeInit = true; |
| mPendingCaptureSettings = 0; |
| mPendingReprocessSettings = 0; |
| mFramesWithDucati = 0; |
| mFramesWithDisplay = 0; |
| mFramesWithEncoder = 0; |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::setSensorOverclock(bool enable) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_BOOLEANTYPE bOMX; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateLoaded != mComponentState ) |
| { |
| CAMHAL_LOGDA("OMX component is not in loaded state"); |
| return ret; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE); |
| |
| if ( enable ) |
| { |
| bOMX.bEnabled = OMX_TRUE; |
| } |
| else |
| { |
| bOMX.bEnabled = OMX_FALSE; |
| } |
| |
| CAMHAL_LOGDB("Configuring Sensor overclock mode 0x%x", bOMX.bEnabled); |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParamSensorOverClockMode, &bOMX); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while setting Sensor overclock 0x%x", eError); |
| } |
| else |
| { |
| mSensorOverclock = enable; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::printComponentVersion(OMX_HANDLETYPE handle) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_VERSIONTYPE compVersion; |
| char compName[OMX_MAX_STRINGNAME_SIZE]; |
| char *currentUUID = NULL; |
| size_t offset = 0; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( NULL == handle ) |
| { |
| CAMHAL_LOGEB("Invalid OMX Handle =0x%x", ( unsigned int ) handle); |
| ret = -EINVAL; |
| } |
| |
| mCompUUID[0] = 0; |
| |
| if ( NO_ERROR == ret ) |
| { |
| eError = OMX_GetComponentVersion(handle, |
| compName, |
| &compVersion, |
| &mCompRevision, |
| &mCompUUID |
| ); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("OMX_GetComponentVersion returned 0x%x", eError); |
| ret = BAD_VALUE; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGVB("OMX Component name: [%s]", compName); |
| CAMHAL_LOGVB("OMX Component version: [%u]", ( unsigned int ) compVersion.nVersion); |
| CAMHAL_LOGVB("Spec version: [%u]", ( unsigned int ) mCompRevision.nVersion); |
| CAMHAL_LOGVB("Git Commit ID: [%s]", mCompUUID); |
| currentUUID = ( char * ) mCompUUID; |
| } |
| |
| if ( NULL != currentUUID ) |
| { |
| offset = strlen( ( const char * ) mCompUUID) + 1; |
| if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE ) |
| { |
| currentUUID += offset; |
| CAMHAL_LOGVB("Git Branch: [%s]", currentUUID); |
| } |
| else |
| { |
| ret = BAD_VALUE; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| offset = strlen( ( const char * ) currentUUID) + 1; |
| |
| if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE ) |
| { |
| currentUUID += offset; |
| CAMHAL_LOGVB("Build date and time: [%s]", currentUUID); |
| } |
| else |
| { |
| ret = BAD_VALUE; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| offset = strlen( ( const char * ) currentUUID) + 1; |
| |
| if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE ) |
| { |
| currentUUID += offset; |
| CAMHAL_LOGVB("Build description: [%s]", currentUUID); |
| } |
| else |
| { |
| ret = BAD_VALUE; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setS3DFrameLayout(OMX_U32 port) const |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_FRAMELAYOUTTYPE frameLayout; |
| const OMXCameraPortParameters *cap = |
| &mCameraAdapterParameters.mCameraPortParams[port]; |
| |
| LOG_FUNCTION_NAME; |
| |
| OMX_INIT_STRUCT_PTR (&frameLayout, OMX_TI_FRAMELAYOUTTYPE); |
| frameLayout.nPortIndex = port; |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexParamStereoFrmLayout, &frameLayout); |
| if (eError != OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("Error while getting S3D frame layout: 0x%x", eError); |
| return -EINVAL; |
| } |
| |
| if (cap->mFrameLayoutType == OMX_TI_StereoFrameLayoutTopBottomSubsample) |
| { |
| frameLayout.eFrameLayout = OMX_TI_StereoFrameLayoutTopBottom; |
| frameLayout.nSubsampleRatio = 2; |
| } |
| else if (cap->mFrameLayoutType == |
| OMX_TI_StereoFrameLayoutLeftRightSubsample) |
| { |
| frameLayout.eFrameLayout = OMX_TI_StereoFrameLayoutLeftRight; |
| frameLayout.nSubsampleRatio = 2; |
| } |
| else |
| { |
| frameLayout.eFrameLayout = cap->mFrameLayoutType; |
| frameLayout.nSubsampleRatio = 1; |
| } |
| frameLayout.nSubsampleRatio = frameLayout.nSubsampleRatio << 7; |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexParamStereoFrmLayout, &frameLayout); |
| if (eError != OMX_ErrorNone) |
| { |
| CAMHAL_LOGEB("Error while setting S3D frame layout: 0x%x", eError); |
| return -EINVAL; |
| } |
| else |
| { |
| CAMHAL_LOGDB("S3D frame layout %d applied successfully on port %lu", |
| frameLayout.eFrameLayout, port); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return NO_ERROR; |
| } |
| |
| status_t OMXCameraAdapter::autoFocus() |
| { |
| status_t ret = NO_ERROR; |
| Utils::Message msg; |
| |
| LOG_FUNCTION_NAME; |
| |
| { |
| android::AutoMutex lock(mFrameCountMutex); |
| if (mFrameCount < 1) { |
| // first frame may time some time to come...so wait for an adequate amount of time |
| // which 2 * OMX_CAPTURE_TIMEOUT * 1000 will cover. |
| ret = mFirstFrameCondition.waitRelative(mFrameCountMutex, |
| (nsecs_t) 2 * OMX_CAPTURE_TIMEOUT * 1000); |
| if ((NO_ERROR != ret) || (mFrameCount == 0)) { |
| goto EXIT; |
| } |
| } |
| } |
| |
| msg.command = CommandHandler::CAMERA_PERFORM_AUTOFOCUS; |
| msg.arg1 = mErrorNotifier; |
| ret = mCommandHandler->put(&msg); |
| |
| EXIT: |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::takePicture() |
| { |
| status_t ret = NO_ERROR; |
| Utils::Message msg; |
| |
| LOG_FUNCTION_NAME; |
| |
| if (mNextState != REPROCESS_STATE) { |
| android::AutoMutex lock(mFrameCountMutex); |
| if (mFrameCount < 1) { |
| // first frame may time some time to come...so wait for an adequate amount of time |
| // which 2 * OMX_CAPTURE_TIMEOUT * 1000 will cover. |
| ret = mFirstFrameCondition.waitRelative(mFrameCountMutex, |
| (nsecs_t) 2 * OMX_CAPTURE_TIMEOUT * 1000); |
| if ((NO_ERROR != ret) || (mFrameCount == 0)) { |
| goto EXIT; |
| } |
| } |
| } |
| |
| // TODO(XXX): re-using take picture to kick off reprocessing pipe |
| // Need to rethink this approach during reimplementation |
| if (mNextState == REPROCESS_STATE) { |
| msg.command = CommandHandler::CAMERA_START_REPROCESS; |
| } else { |
| msg.command = CommandHandler::CAMERA_START_IMAGE_CAPTURE; |
| } |
| |
| msg.arg1 = mErrorNotifier; |
| msg.arg2 = cacheCaptureParameters(); |
| ret = mCommandHandler->put(&msg); |
| |
| EXIT: |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::startVideoCapture() |
| { |
| return BaseCameraAdapter::startVideoCapture(); |
| } |
| |
| status_t OMXCameraAdapter::stopVideoCapture() |
| { |
| return BaseCameraAdapter::stopVideoCapture(); |
| } |
| |
| //API to get the frame size required to be allocated. This size is used to override the size passed |
| //by camera service when VSTAB/VNF is turned ON for example |
| status_t OMXCameraAdapter::getFrameSize(size_t &width, size_t &height) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_RECTTYPE tFrameDim; |
| |
| LOG_FUNCTION_NAME; |
| |
| OMX_INIT_STRUCT_PTR (&tFrameDim, OMX_CONFIG_RECTTYPE); |
| tFrameDim.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| if ( mOMXStateSwitch ) |
| { |
| ret = switchToLoaded(true); |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEB("switchToLoaded() failed 0x%x", ret); |
| goto exit; |
| } |
| |
| mOMXStateSwitch = false; |
| } |
| |
| if ( OMX_StateLoaded == mComponentState ) |
| { |
| |
| if (mPendingPreviewSettings & SetLDC) { |
| mPendingPreviewSettings &= ~SetLDC; |
| ret = setLDC(mIPP); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("setLDC() failed %d", ret); |
| LOG_FUNCTION_NAME_EXIT; |
| goto exit; |
| } |
| } |
| |
| if (mPendingPreviewSettings & SetNSF) { |
| mPendingPreviewSettings &= ~SetNSF; |
| ret = setNSF(mIPP); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("setNSF() failed %d", ret); |
| LOG_FUNCTION_NAME_EXIT; |
| goto exit; |
| } |
| } |
| |
| if (mPendingPreviewSettings & SetCapMode) { |
| mPendingPreviewSettings &= ~SetCapMode; |
| ret = setCaptureMode(mCapMode); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("setCaptureMode() failed %d", ret); |
| } |
| } |
| |
| if((mCapMode == OMXCameraAdapter::VIDEO_MODE) || |
| (mCapMode == OMXCameraAdapter::VIDEO_MODE_HQ) ) { |
| |
| if (mPendingPreviewSettings & SetVNF) { |
| mPendingPreviewSettings &= ~SetVNF; |
| ret = enableVideoNoiseFilter(mVnfEnabled); |
| if ( NO_ERROR != ret){ |
| CAMHAL_LOGEB("Error configuring VNF %x", ret); |
| } |
| } |
| |
| if (mPendingPreviewSettings & SetVSTAB) { |
| mPendingPreviewSettings &= ~SetVSTAB; |
| ret = enableVideoStabilization(mVstabEnabled); |
| if ( NO_ERROR != ret) { |
| CAMHAL_LOGEB("Error configuring VSTAB %x", ret); |
| } |
| } |
| |
| } |
| } |
| |
| ret = setSensorOrientation(mSensorOrientation); |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret); |
| mSensorOrientation = 0; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParam2DBufferAllocDimension, &tFrameDim); |
| if ( OMX_ErrorNone == eError) |
| { |
| width = tFrameDim.nWidth; |
| height = tFrameDim.nHeight; |
| } |
| } |
| |
| exit: |
| |
| CAMHAL_LOGDB("Required frame size %dx%d", width, height); |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount) |
| { |
| status_t ret = NO_ERROR; |
| OMX_PARAM_PORTDEFINITIONTYPE portCheck; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateLoaded != mComponentState ) |
| { |
| CAMHAL_LOGEA("Calling getFrameDataSize() when not in LOADED state"); |
| dataFrameSize = 0; |
| ret = BAD_VALUE; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR(&portCheck, OMX_PARAM_PORTDEFINITIONTYPE); |
| portCheck.nPortIndex = mCameraAdapterParameters.mMeasurementPortIndex; |
| |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError); |
| dataFrameSize = 0; |
| ret = BAD_VALUE; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| portCheck.nBufferCountActual = bufferCount; |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("OMX_SetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError); |
| dataFrameSize = 0; |
| ret = BAD_VALUE; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError); |
| ret = BAD_VALUE; |
| } |
| else |
| { |
| mCameraAdapterParameters.mCameraPortParams[portCheck.nPortIndex].mBufSize = portCheck.nBufferSize; |
| dataFrameSize = portCheck.nBufferSize; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| void OMXCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt) |
| { |
| LOG_FUNCTION_NAME; |
| |
| static const unsigned int DEGREES_TILT_IGNORE = 45; |
| |
| // if tilt angle is greater than DEGREES_TILT_IGNORE |
| // we are going to ignore the orientation returned from |
| // sensor. the orientation returned from sensor is not |
| // reliable. Value of DEGREES_TILT_IGNORE may need adjusting |
| if (tilt > DEGREES_TILT_IGNORE) { |
| return; |
| } |
| |
| int mountOrientation = 0; |
| bool isFront = false; |
| if (mCapabilities) { |
| const char * const mountOrientationString = |
| mCapabilities->get(CameraProperties::ORIENTATION_INDEX); |
| if (mountOrientationString) { |
| mountOrientation = atoi(mountOrientationString); |
| } |
| |
| const char * const facingString = mCapabilities->get(CameraProperties::FACING_INDEX); |
| if (facingString) { |
| isFront = strcmp(facingString, TICameraParameters::FACING_FRONT) == 0; |
| } |
| } |
| |
| // direction is a constant sign for facing, meaning the rotation direction relative to device |
| // +1 (clockwise) for back sensor and -1 (counter-clockwise) for front sensor |
| const int direction = isFront ? -1 : 1; |
| |
| int rotation = mountOrientation + direction*orientation; |
| |
| // crop the calculated value to [0..360) range |
| while ( rotation < 0 ) rotation += 360; |
| rotation %= 360; |
| |
| if (rotation != mDeviceOrientation) { |
| mDeviceOrientation = rotation; |
| |
| // restart face detection with new rotation |
| setFaceDetectionOrientation(mDeviceOrientation); |
| } |
| CAMHAL_LOGVB("orientation = %d tilt = %d device_orientation = %d", orientation, tilt, mDeviceOrientation); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| } |
| |
| /* Application callback Functions */ |
| /*========================================================*/ |
| /* @ fn SampleTest_EventHandler :: Application callback */ |
| /*========================================================*/ |
| OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_PTR pAppData, |
| OMX_IN OMX_EVENTTYPE eEvent, |
| OMX_IN OMX_U32 nData1, |
| OMX_IN OMX_U32 nData2, |
| OMX_IN OMX_PTR pEventData) |
| { |
| LOG_FUNCTION_NAME; |
| |
| CAMHAL_LOGDB("Event %d", eEvent); |
| |
| OMX_ERRORTYPE ret = OMX_ErrorNone; |
| OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData; |
| ret = oca->OMXCameraAdapterEventHandler(hComponent, eEvent, nData1, nData2, pEventData); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return ret; |
| } |
| |
| /* Application callback Functions */ |
| /*========================================================*/ |
| /* @ fn SampleTest_EventHandler :: Application callback */ |
| /*========================================================*/ |
| OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_EVENTTYPE eEvent, |
| OMX_IN OMX_U32 nData1, |
| OMX_IN OMX_U32 nData2, |
| OMX_IN OMX_PTR pEventData) |
| { |
| |
| LOG_FUNCTION_NAME; |
| |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| CAMHAL_LOGDB("+OMX_Event %x, %d %d", eEvent, (int)nData1, (int)nData2); |
| |
| switch (eEvent) { |
| case OMX_EventCmdComplete: |
| CAMHAL_LOGDB("+OMX_EventCmdComplete %d %d", (int)nData1, (int)nData2); |
| |
| if (OMX_CommandStateSet == nData1) { |
| mCameraAdapterParameters.mState = (OMX_STATETYPE) nData2; |
| |
| } else if (OMX_CommandFlush == nData1) { |
| CAMHAL_LOGDB("OMX_CommandFlush received for port %d", (int)nData2); |
| |
| } else if (OMX_CommandPortDisable == nData1) { |
| CAMHAL_LOGDB("OMX_CommandPortDisable received for port %d", (int)nData2); |
| |
| } else if (OMX_CommandPortEnable == nData1) { |
| CAMHAL_LOGDB("OMX_CommandPortEnable received for port %d", (int)nData2); |
| |
| } else if (OMX_CommandMarkBuffer == nData1) { |
| ///This is not used currently |
| } |
| |
| CAMHAL_LOGDA("-OMX_EventCmdComplete"); |
| break; |
| |
| case OMX_EventIndexSettingChanged: |
| CAMHAL_LOGDB("OMX_EventIndexSettingChanged event received data1 0x%x, data2 0x%x", |
| ( unsigned int ) nData1, ( unsigned int ) nData2); |
| break; |
| |
| case OMX_EventError: |
| CAMHAL_LOGDB("OMX interface failed to execute OMX command %d", (int)nData1); |
| CAMHAL_LOGDA("See OMX_INDEXTYPE for reference"); |
| if ( NULL != mErrorNotifier && ( ( OMX_U32 ) OMX_ErrorHardware == nData1 ) && mComponentState != OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("***Got Fatal Error Notification***\n"); |
| mComponentState = OMX_StateInvalid; |
| /* |
| Remove any unhandled events and |
| unblock any waiting semaphores |
| */ |
| if ( !mEventSignalQ.isEmpty() ) |
| { |
| for (unsigned int i = 0 ; i < mEventSignalQ.size(); i++ ) |
| { |
| CAMHAL_LOGEB("***Removing %d EVENTS***** \n", mEventSignalQ.size()); |
| //remove from queue and free msg |
| Utils::Message *msg = mEventSignalQ.itemAt(i); |
| if ( NULL != msg ) |
| { |
| Utils::Semaphore *sem = (Utils::Semaphore*) msg->arg3; |
| if ( sem ) |
| { |
| sem->Signal(); |
| } |
| free(msg); |
| } |
| } |
| mEventSignalQ.clear(); |
| } |
| ///Report Error to App |
| mErrorNotifier->errorNotify(CAMERA_ERROR_FATAL); |
| } |
| break; |
| |
| case OMX_EventMark: |
| break; |
| |
| case OMX_EventPortSettingsChanged: |
| break; |
| |
| case OMX_EventBufferFlag: |
| break; |
| |
| case OMX_EventResourcesAcquired: |
| break; |
| |
| case OMX_EventComponentResumed: |
| break; |
| |
| case OMX_EventDynamicResourcesAvailable: |
| break; |
| |
| case OMX_EventPortFormatDetected: |
| break; |
| |
| default: |
| break; |
| } |
| |
| ///Signal to the thread(s) waiting that the event has occured |
| SignalEvent(hComponent, eEvent, nData1, nData2, pEventData); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return eError; |
| |
| EXIT: |
| |
| CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError); |
| LOG_FUNCTION_NAME_EXIT; |
| return eError; |
| } |
| |
| OMX_ERRORTYPE OMXCameraAdapter::SignalEvent(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_EVENTTYPE eEvent, |
| OMX_IN OMX_U32 nData1, |
| OMX_IN OMX_U32 nData2, |
| OMX_IN OMX_PTR pEventData) |
| { |
| android::AutoMutex lock(mEventLock); |
| Utils::Message *msg; |
| bool eventSignalled = false; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( !mEventSignalQ.isEmpty() ) |
| { |
| CAMHAL_LOGDA("Event queue not empty"); |
| |
| for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ ) |
| { |
| msg = mEventSignalQ.itemAt(i); |
| if ( NULL != msg ) |
| { |
| if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) ) |
| && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 ) |
| && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 ) |
| && msg->arg3) |
| { |
| Utils::Semaphore *sem = (Utils::Semaphore*) msg->arg3; |
| CAMHAL_LOGDA("Event matched, signalling sem"); |
| mEventSignalQ.removeAt(i); |
| //Signal the semaphore provided |
| sem->Signal(); |
| free(msg); |
| eventSignalled = true; |
| break; |
| } |
| } |
| } |
| } |
| else |
| { |
| CAMHAL_LOGDA("Event queue empty!!!"); |
| } |
| |
| // Special handling for any unregistered events |
| if (!eventSignalled) { |
| // Handling for focus callback |
| if ((nData2 == OMX_IndexConfigCommonFocusStatus) && |
| (eEvent == (OMX_EVENTTYPE) OMX_EventIndexSettingChanged)) { |
| Utils::Message msg; |
| msg.command = OMXCallbackHandler::CAMERA_FOCUS_STATUS; |
| msg.arg1 = NULL; |
| msg.arg2 = NULL; |
| mOMXCallbackHandler->put(&msg); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return OMX_ErrorNone; |
| } |
| |
| OMX_ERRORTYPE OMXCameraAdapter::RemoveEvent(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_EVENTTYPE eEvent, |
| OMX_IN OMX_U32 nData1, |
| OMX_IN OMX_U32 nData2, |
| OMX_IN OMX_PTR pEventData) |
| { |
| android::AutoMutex lock(mEventLock); |
| Utils::Message *msg; |
| LOG_FUNCTION_NAME; |
| |
| if ( !mEventSignalQ.isEmpty() ) |
| { |
| CAMHAL_LOGDA("Event queue not empty"); |
| |
| for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ ) |
| { |
| msg = mEventSignalQ.itemAt(i); |
| if ( NULL != msg ) |
| { |
| if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) ) |
| && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 ) |
| && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 ) |
| && msg->arg3) |
| { |
| Utils::Semaphore *sem = (Utils::Semaphore*) msg->arg3; |
| CAMHAL_LOGDA("Event matched, signalling sem"); |
| mEventSignalQ.removeAt(i); |
| free(msg); |
| break; |
| } |
| } |
| } |
| } |
| else |
| { |
| CAMHAL_LOGEA("Event queue empty!!!"); |
| } |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return OMX_ErrorNone; |
| } |
| |
| |
| status_t OMXCameraAdapter::RegisterForEvent(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_EVENTTYPE eEvent, |
| OMX_IN OMX_U32 nData1, |
| OMX_IN OMX_U32 nData2, |
| OMX_IN Utils::Semaphore &semaphore) |
| { |
| status_t ret = NO_ERROR; |
| ssize_t res; |
| android::AutoMutex lock(mEventLock); |
| |
| LOG_FUNCTION_NAME; |
| Utils::Message * msg = ( struct Utils::Message * ) malloc(sizeof(struct Utils::Message)); |
| if ( NULL != msg ) |
| { |
| msg->command = ( unsigned int ) eEvent; |
| msg->arg1 = ( void * ) nData1; |
| msg->arg2 = ( void * ) nData2; |
| msg->arg3 = ( void * ) &semaphore; |
| msg->arg4 = ( void * ) hComponent; |
| res = mEventSignalQ.add(msg); |
| if ( NO_MEMORY == res ) |
| { |
| CAMHAL_LOGEA("No ressources for inserting OMX events"); |
| free(msg); |
| ret = -ENOMEM; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| /*========================================================*/ |
| /* @ fn SampleTest_EmptyBufferDone :: Application callback*/ |
| /*========================================================*/ |
| OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_PTR pAppData, |
| OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) |
| { |
| LOG_FUNCTION_NAME; |
| |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData; |
| eError = oca->OMXCameraAdapterEmptyBufferDone(hComponent, pBuffHeader); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return eError; |
| } |
| |
| |
| /*========================================================*/ |
| /* @ fn SampleTest_EmptyBufferDone :: Application callback*/ |
| /*========================================================*/ |
| OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) |
| { |
| |
| LOG_FUNCTION_NAME; |
| status_t stat = NO_ERROR; |
| status_t res1, res2; |
| OMXCameraPortParameters *pPortParam; |
| CameraFrame::FrameType typeOfFrame = CameraFrame::ALL_FRAMES; |
| unsigned int refCount = 0; |
| unsigned int mask = 0xFFFF; |
| CameraFrame cameraFrame; |
| OMX_TI_PLATFORMPRIVATE *platformPrivate; |
| |
| res1 = res2 = NO_ERROR; |
| |
| if (!pBuffHeader || !pBuffHeader->pBuffer) { |
| CAMHAL_LOGE("NULL Buffer from OMX"); |
| return OMX_ErrorNone; |
| } |
| |
| pPortParam = &(mCameraAdapterParameters.mCameraPortParams[pBuffHeader->nInputPortIndex]); |
| platformPrivate = (OMX_TI_PLATFORMPRIVATE*) pBuffHeader->pPlatformPrivate; |
| |
| if (pBuffHeader->nInputPortIndex == OMX_CAMERA_PORT_VIDEO_IN_VIDEO) { |
| typeOfFrame = CameraFrame::REPROCESS_INPUT_FRAME; |
| mask = (unsigned int)CameraFrame::REPROCESS_INPUT_FRAME; |
| |
| stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return OMX_ErrorNone; |
| } |
| |
| static void debugShowFPS() |
| { |
| static int mFrameCount = 0; |
| static int mLastFrameCount = 0; |
| static nsecs_t mLastFpsTime = 0; |
| static float mFps = 0; |
| mFrameCount++; |
| if (!(mFrameCount & 0x1F)) { |
| nsecs_t now = systemTime(); |
| nsecs_t diff = now - mLastFpsTime; |
| mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; |
| mLastFpsTime = now; |
| mLastFrameCount = mFrameCount; |
| CAMHAL_LOGI("Camera %d Frames, %f FPS", mFrameCount, mFps); |
| } |
| // XXX: mFPS has the value we want |
| } |
| |
| /*========================================================*/ |
| /* @ fn SampleTest_FillBufferDone :: Application callback*/ |
| /*========================================================*/ |
| OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_PTR pAppData, |
| OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) |
| { |
| Utils::Message msg; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| if (UNLIKELY(mDebugFps)) { |
| debugShowFPS(); |
| } |
| |
| OMXCameraAdapter *adapter = ( OMXCameraAdapter * ) pAppData; |
| if ( NULL != adapter ) |
| { |
| msg.command = OMXCameraAdapter::OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE; |
| msg.arg1 = ( void * ) hComponent; |
| msg.arg2 = ( void * ) pBuffHeader; |
| adapter->mOMXCallbackHandler->put(&msg); |
| } |
| |
| return eError; |
| } |
| |
| #ifdef CAMERAHAL_OMX_PROFILING |
| |
| status_t OMXCameraAdapter::storeProfilingData(OMX_BUFFERHEADERTYPE* pBuffHeader) { |
| OMX_TI_PLATFORMPRIVATE *platformPrivate = NULL; |
| OMX_OTHER_EXTRADATATYPE *extraData = NULL; |
| FILE *fd = NULL; |
| |
| LOG_FUNCTION_NAME |
| |
| if ( UNLIKELY( mDebugProfile ) ) { |
| |
| platformPrivate = static_cast<OMX_TI_PLATFORMPRIVATE *> (pBuffHeader->pPlatformPrivate); |
| extraData = getExtradata(platformPrivate->pMetaDataBuffer, |
| static_cast<OMX_EXTRADATATYPE> (OMX_TI_ProfilerData)); |
| |
| if ( NULL != extraData ) { |
| if( extraData->eType == static_cast<OMX_EXTRADATATYPE> (OMX_TI_ProfilerData) ) { |
| |
| fd = fopen(DEFAULT_PROFILE_PATH, "ab"); |
| if ( NULL != fd ) { |
| fwrite(extraData->data, 1, extraData->nDataSize, fd); |
| fclose(fd); |
| } else { |
| return -errno; |
| } |
| |
| } else { |
| return NOT_ENOUGH_DATA; |
| } |
| } else { |
| return NOT_ENOUGH_DATA; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT |
| |
| return NO_ERROR; |
| } |
| |
| #endif |
| |
| /*========================================================*/ |
| /* @ fn SampleTest_FillBufferDone :: Application callback*/ |
| /*========================================================*/ |
| OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) |
| { |
| |
| status_t stat = NO_ERROR; |
| status_t res1, res2; |
| OMXCameraPortParameters *pPortParam; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| CameraFrame::FrameType typeOfFrame = CameraFrame::ALL_FRAMES; |
| unsigned int refCount = 0; |
| BaseCameraAdapter::AdapterState state, nextState; |
| BaseCameraAdapter::getState(state); |
| BaseCameraAdapter::getNextState(nextState); |
| android::sp<CameraMetadataResult> metadataResult = NULL; |
| unsigned int mask = 0xFFFF; |
| CameraFrame cameraFrame; |
| OMX_OTHER_EXTRADATATYPE *extraData; |
| OMX_TI_ANCILLARYDATATYPE *ancillaryData = NULL; |
| bool snapshotFrame = false; |
| |
| if ( NULL == pBuffHeader ) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| #ifdef CAMERAHAL_OMX_PROFILING |
| |
| storeProfilingData(pBuffHeader); |
| |
| #endif |
| |
| res1 = res2 = NO_ERROR; |
| |
| if ( !pBuffHeader || !pBuffHeader->pBuffer ) { |
| CAMHAL_LOGEA("NULL Buffer from OMX"); |
| return OMX_ErrorNone; |
| } |
| |
| pPortParam = &(mCameraAdapterParameters.mCameraPortParams[pBuffHeader->nOutputPortIndex]); |
| |
| // Find buffer and mark it as filled |
| for (int i = 0; i < pPortParam->mNumBufs; i++) { |
| if (pPortParam->mBufferHeader[i] == pBuffHeader) { |
| pPortParam->mStatus[i] = OMXCameraPortParameters::DONE; |
| } |
| } |
| |
| if (pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW) |
| { |
| |
| if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE ) |
| { |
| return OMX_ErrorNone; |
| } |
| |
| if ( mWaitingForSnapshot ) { |
| extraData = getExtradata(pBuffHeader->pPlatformPrivate, |
| (OMX_EXTRADATATYPE) OMX_AncillaryData); |
| |
| if ( NULL != extraData ) { |
| ancillaryData = (OMX_TI_ANCILLARYDATATYPE*) extraData->data; |
| if ((OMX_2D_Snap == ancillaryData->eCameraView) |
| || (OMX_3D_Left_Snap == ancillaryData->eCameraView) |
| || (OMX_3D_Right_Snap == ancillaryData->eCameraView)) { |
| snapshotFrame = OMX_TRUE; |
| } else { |
| snapshotFrame = OMX_FALSE; |
| } |
| mPending3Asettings |= SetFocus; |
| } |
| } |
| |
| ///Prepare the frames to be sent - initialize CameraFrame object and reference count |
| // TODO(XXX): ancillary data for snapshot frame is not being sent for video snapshot |
| // if we are waiting for a snapshot and in video mode...go ahead and send |
| // this frame as a snapshot |
| if( mWaitingForSnapshot && (mCapturedFrames > 0) && |
| (snapshotFrame || (mCapMode == VIDEO_MODE) || (mCapMode == VIDEO_MODE_HQ ) )) |
| { |
| typeOfFrame = CameraFrame::SNAPSHOT_FRAME; |
| mask = (unsigned int)CameraFrame::SNAPSHOT_FRAME; |
| |
| // video snapshot gets ancillary data and wb info from last snapshot frame |
| mCaptureAncillaryData = ancillaryData; |
| mWhiteBalanceData = NULL; |
| extraData = getExtradata(pBuffHeader->pPlatformPrivate, |
| (OMX_EXTRADATATYPE) OMX_WhiteBalance); |
| if ( NULL != extraData ) |
| { |
| mWhiteBalanceData = (OMX_TI_WHITEBALANCERESULTTYPE*) extraData->data; |
| } |
| } |
| else |
| { |
| typeOfFrame = CameraFrame::PREVIEW_FRAME_SYNC; |
| mask = (unsigned int)CameraFrame::PREVIEW_FRAME_SYNC; |
| } |
| |
| if (mRecording) |
| { |
| mask |= (unsigned int)CameraFrame::VIDEO_FRAME_SYNC; |
| mFramesWithEncoder++; |
| } |
| |
| //CAMHAL_LOGV("FBD pBuffer = 0x%x", pBuffHeader->pBuffer); |
| |
| if( mWaitingForSnapshot ) |
| { |
| if ( !mBracketingEnabled && |
| ((HIGH_SPEED == mCapMode) || |
| (VIDEO_MODE == mCapMode) || |
| (VIDEO_MODE_HQ == mCapMode)) ) |
| { |
| notifyShutterSubscribers(); |
| } |
| } |
| |
| stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam); |
| mFramesWithDisplay++; |
| |
| mFramesWithDucati--; |
| |
| #ifdef CAMERAHAL_DEBUG |
| if(mBuffersWithDucati.indexOfKey((uint32_t)pBuffHeader->pBuffer)<0) |
| { |
| CAMHAL_LOGE("Buffer was never with Ducati!! %p", pBuffHeader->pBuffer); |
| for(unsigned int i=0;i<mBuffersWithDucati.size();i++) CAMHAL_LOGE("0x%x", mBuffersWithDucati.keyAt(i)); |
| } |
| mBuffersWithDucati.removeItem((int)pBuffHeader->pBuffer); |
| #endif |
| |
| if(mDebugFcs) |
| CAMHAL_LOGEB("C[%d] D[%d] E[%d]", mFramesWithDucati, mFramesWithDisplay, mFramesWithEncoder); |
| |
| recalculateFPS(); |
| |
| createPreviewMetadata(pBuffHeader, metadataResult, pPortParam->mWidth, pPortParam->mHeight); |
| if ( NULL != metadataResult.get() ) { |
| notifyMetadataSubscribers(metadataResult); |
| metadataResult.clear(); |
| } |
| |
| { |
| android::AutoMutex lock(mFaceDetectionLock); |
| if ( mFDSwitchAlgoPriority ) { |
| |
| //Disable region priority and enable face priority for AF |
| setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false); |
| setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true); |
| |
| //Disable Region priority and enable Face priority |
| setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false); |
| setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, true); |
| mFDSwitchAlgoPriority = false; |
| } |
| } |
| |
| sniffDccFileDataSave(pBuffHeader); |
| |
| stat |= advanceZoom(); |
| |
| // On the fly update to 3A settings not working |
| // Do not update 3A here if we are in the middle of a capture |
| // or in the middle of transitioning to it |
| if( mPending3Asettings && |
| ( (nextState & CAPTURE_ACTIVE) == 0 ) && |
| ( (state & CAPTURE_ACTIVE) == 0 ) ) { |
| apply3Asettings(mParameters3A); |
| } |
| |
| } |
| else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT ) |
| { |
| typeOfFrame = CameraFrame::FRAME_DATA_SYNC; |
| mask = (unsigned int)CameraFrame::FRAME_DATA_SYNC; |
| |
| stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam); |
| } |
| else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_IMAGE_OUT_IMAGE ) |
| { |
| OMX_COLOR_FORMATTYPE pixFormat; |
| const char *valstr = NULL; |
| |
| pixFormat = pPortParam->mColorFormat; |
| |
| if ( OMX_COLOR_FormatUnused == pixFormat ) |
| { |
| typeOfFrame = CameraFrame::IMAGE_FRAME; |
| mask = (unsigned int) CameraFrame::IMAGE_FRAME; |
| } else if ( pixFormat == OMX_COLOR_FormatCbYCrY && |
| ((mPictureFormatFromClient && |
| !strcmp(mPictureFormatFromClient, |
| android::CameraParameters::PIXEL_FORMAT_JPEG)) || |
| !mPictureFormatFromClient) ) { |
| // signals to callbacks that this needs to be coverted to jpeg |
| // before returning to framework |
| typeOfFrame = CameraFrame::IMAGE_FRAME; |
| mask = (unsigned int) CameraFrame::IMAGE_FRAME; |
| cameraFrame.mQuirks |= CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG; |
| cameraFrame.mQuirks |= CameraFrame::FORMAT_YUV422I_UYVY; |
| |
| // populate exif data and pass to subscribers via quirk |
| // subscriber is in charge of freeing exif data |
| ExifElementsTable* exif = new ExifElementsTable(); |
| setupEXIF_libjpeg(exif, mCaptureAncillaryData, mWhiteBalanceData); |
| cameraFrame.mQuirks |= CameraFrame::HAS_EXIF_DATA; |
| cameraFrame.mCookie2 = (void*) exif; |
| } else { |
| typeOfFrame = CameraFrame::RAW_FRAME; |
| mask = (unsigned int) CameraFrame::RAW_FRAME; |
| } |
| |
| pPortParam->mImageType = typeOfFrame; |
| |
| if((mCapturedFrames>0) && !mCaptureSignalled) |
| { |
| mCaptureSignalled = true; |
| mCaptureSem.Signal(); |
| } |
| |
| if( ( CAPTURE_ACTIVE & state ) != CAPTURE_ACTIVE ) |
| { |
| goto EXIT; |
| } |
| |
| { |
| android::AutoMutex lock(mBracketingLock); |
| if ( mBracketingEnabled ) |
| { |
| doBracketing(pBuffHeader, typeOfFrame); |
| return eError; |
| } |
| } |
| |
| if (mZoomBracketingEnabled) { |
| doZoom(mZoomBracketingValues[mCurrentZoomBracketing]); |
| CAMHAL_LOGDB("Current Zoom Bracketing: %d", mZoomBracketingValues[mCurrentZoomBracketing]); |
| mCurrentZoomBracketing++; |
| if (mCurrentZoomBracketing == ARRAY_SIZE(mZoomBracketingValues)) { |
| mZoomBracketingEnabled = false; |
| } |
| } |
| |
| if ( 1 > mCapturedFrames ) |
| { |
| goto EXIT; |
| } |
| |
| #ifdef OMAP_ENHANCEMENT_CPCAM |
| if ( NULL != mSharedAllocator ) { |
| cameraFrame.mMetaData = new CameraMetadataResult(getMetaData(pBuffHeader->pPlatformPrivate, mSharedAllocator)); |
| } |
| #endif |
| |
| CAMHAL_LOGDB("Captured Frames: %d", mCapturedFrames); |
| |
| mCapturedFrames--; |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| if (mYuvCapture) { |
| struct timeval timeStampUsec; |
| gettimeofday(&timeStampUsec, NULL); |
| |
| time_t saveTime; |
| time(&saveTime); |
| const struct tm * const timeStamp = gmtime(&saveTime); |
| |
| char filename[256]; |
| snprintf(filename,256, "%s/yuv_%d_%d_%d_%lu.yuv", |
| kYuvImagesOutputDirPath, |
| timeStamp->tm_hour, |
| timeStamp->tm_min, |
| timeStamp->tm_sec, |
| timeStampUsec.tv_usec); |
| |
| const status_t saveBufferStatus = saveBufferToFile(((CameraBuffer*)pBuffHeader->pAppPrivate)->mapped, |
| pBuffHeader->nFilledLen, filename); |
| |
| if (saveBufferStatus != OK) { |
| CAMHAL_LOGE("ERROR: %d, while saving yuv!", saveBufferStatus); |
| } else { |
| CAMHAL_LOGD("yuv_%d_%d_%d_%lu.yuv successfully saved in %s", |
| timeStamp->tm_hour, |
| timeStamp->tm_min, |
| timeStamp->tm_sec, |
| timeStampUsec.tv_usec, |
| kYuvImagesOutputDirPath); |
| } |
| } |
| #endif |
| |
| stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam); |
| #ifdef OMAP_ENHANCEMENT_CPCAM |
| if ( NULL != cameraFrame.mMetaData.get() ) { |
| cameraFrame.mMetaData.clear(); |
| } |
| #endif |
| |
| } |
| else if (pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_VIDEO) { |
| typeOfFrame = CameraFrame::RAW_FRAME; |
| pPortParam->mImageType = typeOfFrame; |
| { |
| android::AutoMutex lock(mLock); |
| if( ( CAPTURE_ACTIVE & state ) != CAPTURE_ACTIVE ) { |
| goto EXIT; |
| } |
| } |
| |
| CAMHAL_LOGD("RAW buffer done on video port, length = %d", pBuffHeader->nFilledLen); |
| |
| mask = (unsigned int) CameraFrame::RAW_FRAME; |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| if ( mRawCapture ) { |
| struct timeval timeStampUsec; |
| gettimeofday(&timeStampUsec, NULL); |
| |
| time_t saveTime; |
| time(&saveTime); |
| const struct tm * const timeStamp = gmtime(&saveTime); |
| |
| char filename[256]; |
| snprintf(filename,256, "%s/raw_%d_%d_%d_%lu.raw", |
| kRawImagesOutputDirPath, |
| timeStamp->tm_hour, |
| timeStamp->tm_min, |
| timeStamp->tm_sec, |
| timeStampUsec.tv_usec); |
| |
| const status_t saveBufferStatus = saveBufferToFile( ((CameraBuffer*)pBuffHeader->pAppPrivate)->mapped, |
| pBuffHeader->nFilledLen, filename); |
| |
| if (saveBufferStatus != OK) { |
| CAMHAL_LOGE("ERROR: %d , while saving raw!", saveBufferStatus); |
| } else { |
| CAMHAL_LOGD("raw_%d_%d_%d_%lu.raw successfully saved in %s", |
| timeStamp->tm_hour, |
| timeStamp->tm_min, |
| timeStamp->tm_sec, |
| timeStampUsec.tv_usec, |
| kRawImagesOutputDirPath); |
| stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam); |
| } |
| } |
| #endif |
| } else { |
| CAMHAL_LOGEA("Frame received for non-(preview/capture/measure) port. This is yet to be supported"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR != stat ) |
| { |
| CameraBuffer *camera_buffer; |
| |
| camera_buffer = (CameraBuffer *)pBuffHeader->pAppPrivate; |
| |
| CAMHAL_LOGDB("sendFrameToSubscribers error: %d", stat); |
| returnFrame(camera_buffer, typeOfFrame); |
| } |
| |
| return eError; |
| |
| EXIT: |
| |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, stat, eError); |
| |
| if ( NO_ERROR != stat ) |
| { |
| if ( NULL != mErrorNotifier ) |
| { |
| mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN); |
| } |
| } |
| |
| return eError; |
| } |
| |
| status_t OMXCameraAdapter::recalculateFPS() |
| { |
| float currentFPS; |
| |
| { |
| android::AutoMutex lock(mFrameCountMutex); |
| mFrameCount++; |
| if (mFrameCount == 1) { |
| mFirstFrameCondition.broadcast(); |
| } |
| } |
| |
| if ( ( mFrameCount % FPS_PERIOD ) == 0 ) |
| { |
| nsecs_t now = systemTime(); |
| nsecs_t diff = now - mLastFPSTime; |
| currentFPS = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; |
| mLastFPSTime = now; |
| mLastFrameCount = mFrameCount; |
| |
| if ( 1 == mIter ) |
| { |
| mFPS = currentFPS; |
| } |
| else |
| { |
| //cumulative moving average |
| mFPS = mLastFPS + (currentFPS - mLastFPS)/mIter; |
| } |
| |
| mLastFPS = mFPS; |
| mIter++; |
| } |
| |
| return NO_ERROR; |
| } |
| |
| status_t OMXCameraAdapter::sendCallBacks(CameraFrame frame, OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader, unsigned int mask, OMXCameraPortParameters *port) |
| { |
| status_t ret = NO_ERROR; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( NULL == port) |
| { |
| CAMHAL_LOGEA("Invalid portParam"); |
| return -EINVAL; |
| } |
| |
| if ( NULL == pBuffHeader ) |
| { |
| CAMHAL_LOGEA("Invalid Buffer header"); |
| return -EINVAL; |
| } |
| |
| android::AutoMutex lock(mSubscriberLock); |
| |
| //frame.mFrameType = typeOfFrame; |
| frame.mFrameMask = mask; |
| frame.mBuffer = (CameraBuffer *)pBuffHeader->pAppPrivate; |
| frame.mLength = pBuffHeader->nFilledLen; |
| frame.mAlignment = port->mStride; |
| frame.mOffset = pBuffHeader->nOffset; |
| frame.mWidth = port->mWidth; |
| frame.mHeight = port->mHeight; |
| frame.mYuv[0] = NULL; |
| frame.mYuv[1] = NULL; |
| |
| if ( onlyOnce && mRecording ) |
| { |
| mTimeSourceDelta = (pBuffHeader->nTimeStamp * 1000) - systemTime(SYSTEM_TIME_MONOTONIC); |
| onlyOnce = false; |
| } |
| |
| frame.mTimestamp = (pBuffHeader->nTimeStamp * 1000) - mTimeSourceDelta; |
| |
| ret = setInitFrameRefCount(frame.mBuffer, mask); |
| |
| if (ret != NO_ERROR) { |
| CAMHAL_LOGDB("Error in setInitFrameRefCount %d", ret); |
| } else { |
| ret = sendFrameToSubscribers(&frame); |
| } |
| |
| CAMHAL_LOGVB("B 0x%x T %llu", frame.mBuffer, pBuffHeader->nTimeStamp); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| bool OMXCameraAdapter::CommandHandler::Handler() |
| { |
| Utils::Message msg; |
| volatile int forever = 1; |
| status_t stat; |
| ErrorNotifier *errorNotify = NULL; |
| |
| LOG_FUNCTION_NAME; |
| |
| while ( forever ) |
| { |
| stat = NO_ERROR; |
| CAMHAL_LOGDA("Handler: waiting for messsage..."); |
| Utils::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1); |
| { |
| android::AutoMutex lock(mLock); |
| mCommandMsgQ.get(&msg); |
| } |
| CAMHAL_LOGDB("msg.command = %d", msg.command); |
| switch ( msg.command ) { |
| case CommandHandler::CAMERA_START_IMAGE_CAPTURE: |
| { |
| OMXCameraAdapter::CachedCaptureParameters* cap_params = |
| static_cast<OMXCameraAdapter::CachedCaptureParameters*>(msg.arg2); |
| stat = mCameraAdapter->startImageCapture(false, cap_params); |
| delete cap_params; |
| break; |
| } |
| case CommandHandler::CAMERA_PERFORM_AUTOFOCUS: |
| { |
| stat = mCameraAdapter->doAutoFocus(); |
| break; |
| } |
| case CommandHandler::COMMAND_EXIT: |
| { |
| CAMHAL_LOGDA("Exiting command handler"); |
| forever = 0; |
| break; |
| } |
| case CommandHandler::CAMERA_SWITCH_TO_EXECUTING: |
| { |
| stat = mCameraAdapter->doSwitchToExecuting(); |
| break; |
| } |
| case CommandHandler::CAMERA_START_REPROCESS: |
| { |
| OMXCameraAdapter::CachedCaptureParameters* cap_params = |
| static_cast<OMXCameraAdapter::CachedCaptureParameters*>(msg.arg2); |
| stat = mCameraAdapter->startReprocess(); |
| stat = mCameraAdapter->startImageCapture(false, cap_params); |
| delete cap_params; |
| break; |
| } |
| } |
| |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return false; |
| } |
| |
| bool OMXCameraAdapter::OMXCallbackHandler::Handler() |
| { |
| Utils::Message msg; |
| volatile int forever = 1; |
| status_t ret = NO_ERROR; |
| |
| LOG_FUNCTION_NAME; |
| |
| while(forever){ |
| Utils::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1); |
| { |
| android::AutoMutex lock(mLock); |
| mCommandMsgQ.get(&msg); |
| mIsProcessed = false; |
| } |
| |
| switch ( msg.command ) { |
| case OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE: |
| { |
| ret = mCameraAdapter->OMXCameraAdapterFillBufferDone(( OMX_HANDLETYPE ) msg.arg1, |
| ( OMX_BUFFERHEADERTYPE *) msg.arg2); |
| break; |
| } |
| case OMXCallbackHandler::CAMERA_FOCUS_STATUS: |
| { |
| mCameraAdapter->handleFocusCallback(); |
| break; |
| } |
| case CommandHandler::COMMAND_EXIT: |
| { |
| CAMHAL_LOGDA("Exiting OMX callback handler"); |
| forever = 0; |
| break; |
| } |
| } |
| |
| { |
| android::AutoMutex locker(mLock); |
| CAMHAL_UNUSED(locker); |
| |
| mIsProcessed = mCommandMsgQ.isEmpty(); |
| if ( mIsProcessed ) |
| mCondition.signal(); |
| } |
| } |
| |
| // force the condition to wake |
| { |
| android::AutoMutex locker(mLock); |
| CAMHAL_UNUSED(locker); |
| |
| mIsProcessed = true; |
| mCondition.signal(); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| return false; |
| } |
| |
| void OMXCameraAdapter::OMXCallbackHandler::flush() |
| { |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex locker(mLock); |
| CAMHAL_UNUSED(locker); |
| |
| if ( mIsProcessed ) |
| return; |
| |
| mCondition.wait(mLock); |
| } |
| |
| status_t OMXCameraAdapter::setExtraData(bool enable, OMX_U32 nPortIndex, OMX_EXT_EXTRADATATYPE eType) { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_EXTRADATATYPE extraDataControl; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( ( OMX_StateInvalid == mComponentState ) || |
| ( NULL == mCameraAdapterParameters.mHandleComp ) ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return -EINVAL; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&extraDataControl, OMX_CONFIG_EXTRADATATYPE); |
| |
| extraDataControl.nPortIndex = nPortIndex; |
| extraDataControl.eExtraDataType = eType; |
| #ifdef CAMERAHAL_TUNA |
| extraDataControl.eCameraView = OMX_2D; |
| #endif |
| |
| if (enable) { |
| extraDataControl.bEnable = OMX_TRUE; |
| } else { |
| extraDataControl.bEnable = OMX_FALSE; |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_IndexConfigOtherExtraDataControl, |
| &extraDataControl); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| OMX_OTHER_EXTRADATATYPE *OMXCameraAdapter::getExtradata(const OMX_PTR ptrPrivate, OMX_EXTRADATATYPE type) const |
| { |
| if ( NULL != ptrPrivate ) { |
| const OMX_TI_PLATFORMPRIVATE *platformPrivate = (const OMX_TI_PLATFORMPRIVATE *) ptrPrivate; |
| |
| CAMHAL_LOGVB("Size = %d, sizeof = %d, pAuxBuf = 0x%x, pAuxBufSize= %d, pMetaDataBufer = 0x%x, nMetaDataSize = %d", |
| platformPrivate->nSize, |
| sizeof(OMX_TI_PLATFORMPRIVATE), |
| platformPrivate->pAuxBuf1, |
| platformPrivate->pAuxBufSize1, |
| platformPrivate->pMetaDataBuffer, |
| platformPrivate->nMetaDataSize); |
| if ( sizeof(OMX_TI_PLATFORMPRIVATE) == platformPrivate->nSize ) { |
| if ( 0 < platformPrivate->nMetaDataSize ) { |
| OMX_U32 remainingSize = platformPrivate->nMetaDataSize; |
| OMX_OTHER_EXTRADATATYPE *extraData = (OMX_OTHER_EXTRADATATYPE *) platformPrivate->pMetaDataBuffer; |
| if ( NULL != extraData ) { |
| while ( extraData->eType && extraData->nDataSize && extraData->data && |
| (remainingSize >= extraData->nSize)) { |
| if ( type == extraData->eType ) { |
| return extraData; |
| } |
| remainingSize -= extraData->nSize; |
| extraData = (OMX_OTHER_EXTRADATATYPE*) ((char*)extraData + extraData->nSize); |
| } |
| } else { |
| CAMHAL_LOGEB("OMX_TI_PLATFORMPRIVATE pMetaDataBuffer is NULL"); |
| } |
| } else { |
| CAMHAL_LOGEB("OMX_TI_PLATFORMPRIVATE nMetaDataSize is size is %d", |
| ( unsigned int ) platformPrivate->nMetaDataSize); |
| } |
| } else { |
| CAMHAL_LOGEB("OMX_TI_PLATFORMPRIVATE size mismatch: expected = %d, received = %d", |
| ( unsigned int ) sizeof(OMX_TI_PLATFORMPRIVATE), |
| ( unsigned int ) platformPrivate->nSize); |
| } |
| } else { |
| CAMHAL_LOGEA("Invalid OMX_TI_PLATFORMPRIVATE"); |
| } |
| |
| // Required extradata type wasn't found |
| return NULL; |
| } |
| |
| OMXCameraAdapter::CachedCaptureParameters* OMXCameraAdapter::cacheCaptureParameters() { |
| CachedCaptureParameters* params = new CachedCaptureParameters(); |
| |
| params->mPendingCaptureSettings = mPendingCaptureSettings; |
| params->mPictureRotation = mPictureRotation; |
| memcpy(params->mExposureBracketingValues, |
| mExposureBracketingValues, |
| sizeof(mExposureBracketingValues)); |
| memcpy(params->mExposureGainBracketingValues, |
| mExposureGainBracketingValues, |
| sizeof(mExposureGainBracketingValues)); |
| memcpy(params->mExposureGainBracketingModes, |
| mExposureGainBracketingModes, |
| sizeof(mExposureGainBracketingModes)); |
| params->mExposureBracketingValidEntries = mExposureBracketingValidEntries; |
| params->mExposureBracketMode = mExposureBracketMode; |
| params->mBurstFrames = mBurstFrames; |
| params->mFlushShotConfigQueue = mFlushShotConfigQueue; |
| |
| return params; |
| } |
| |
| OMXCameraAdapter::OMXCameraAdapter(size_t sensor_index) |
| { |
| LOG_FUNCTION_NAME; |
| |
| mOmxInitialized = false; |
| mComponentState = OMX_StateInvalid; |
| mSensorIndex = sensor_index; |
| mPictureRotation = 0; |
| // Initial values |
| mTimeSourceDelta = 0; |
| onlyOnce = true; |
| mDccData.pData = NULL; |
| |
| mInitSem.Create(0); |
| mFlushSem.Create(0); |
| mUsePreviewDataSem.Create(0); |
| mUsePreviewSem.Create(0); |
| mUseCaptureSem.Create(0); |
| mUseReprocessSem.Create(0); |
| mStartPreviewSem.Create(0); |
| mStopPreviewSem.Create(0); |
| mStartCaptureSem.Create(0); |
| mStopCaptureSem.Create(0); |
| mStopReprocSem.Create(0); |
| mSwitchToLoadedSem.Create(0); |
| mCaptureSem.Create(0); |
| |
| mSwitchToExecSem.Create(0); |
| |
| mCameraAdapterParameters.mHandleComp = 0; |
| |
| mUserSetExpLock = OMX_FALSE; |
| mUserSetWbLock = OMX_FALSE; |
| |
| mFramesWithDucati = 0; |
| mFramesWithDisplay = 0; |
| mFramesWithEncoder = 0; |
| |
| #ifdef CAMERAHAL_OMX_PROFILING |
| |
| mDebugProfile = 0; |
| |
| #endif |
| |
| mPreviewPortInitialized = false; |
| |
| LOG_FUNCTION_NAME_EXIT; |
| } |
| |
| OMXCameraAdapter::~OMXCameraAdapter() |
| { |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex lock(gAdapterLock); |
| |
| if ( mOmxInitialized ) { |
| // return to OMX Loaded state |
| switchToLoaded(); |
| |
| saveDccFileDataSave(); |
| |
| closeDccFileDataSave(); |
| // deinit the OMX |
| if ( mComponentState == OMX_StateLoaded || mComponentState == OMX_StateInvalid ) { |
| // free the handle for the Camera component |
| if ( mCameraAdapterParameters.mHandleComp ) { |
| OMX_FreeHandle(mCameraAdapterParameters.mHandleComp); |
| mCameraAdapterParameters.mHandleComp = NULL; |
| } |
| } |
| |
| OMX_Deinit(); |
| mOmxInitialized = false; |
| } |
| |
| //Remove any unhandled events |
| if ( !mEventSignalQ.isEmpty() ) |
| { |
| for (unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ ) |
| { |
| Utils::Message *msg = mEventSignalQ.itemAt(i); |
| //remove from queue and free msg |
| if ( NULL != msg ) |
| { |
| Utils::Semaphore *sem = (Utils::Semaphore*) msg->arg3; |
| sem->Signal(); |
| free(msg); |
| |
| } |
| } |
| mEventSignalQ.clear(); |
| } |
| |
| //Exit and free ref to command handling thread |
| if ( NULL != mCommandHandler.get() ) |
| { |
| Utils::Message msg; |
| msg.command = CommandHandler::COMMAND_EXIT; |
| msg.arg1 = mErrorNotifier; |
| mCommandHandler->clearCommandQ(); |
| mCommandHandler->put(&msg); |
| mCommandHandler->requestExitAndWait(); |
| mCommandHandler.clear(); |
| } |
| |
| //Exit and free ref to callback handling thread |
| if ( NULL != mOMXCallbackHandler.get() ) |
| { |
| Utils::Message msg; |
| msg.command = OMXCallbackHandler::COMMAND_EXIT; |
| //Clear all messages pending first |
| mOMXCallbackHandler->clearCommandQ(); |
| mOMXCallbackHandler->put(&msg); |
| mOMXCallbackHandler->requestExitAndWait(); |
| mOMXCallbackHandler.clear(); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| } |
| |
| extern "C" CameraAdapter* OMXCameraAdapter_Factory(size_t sensor_index) |
| { |
| CameraAdapter *adapter = NULL; |
| android::AutoMutex lock(gAdapterLock); |
| |
| LOG_FUNCTION_NAME; |
| |
| adapter = new OMXCameraAdapter(sensor_index); |
| if ( adapter ) { |
| CAMHAL_LOGDB("New OMX Camera adapter instance created for sensor %d",sensor_index); |
| } else { |
| CAMHAL_LOGEA("OMX Camera adapter create failed for sensor index = %d!",sensor_index); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return adapter; |
| } |
| |
| OMX_ERRORTYPE OMXCameraAdapter::OMXCameraGetHandle(OMX_HANDLETYPE *handle, OMX_PTR pAppData, |
| const OMX_CALLBACKTYPE & callbacks) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorUndefined; |
| |
| for ( int i = 0; i < 5; ++i ) { |
| if ( i > 0 ) { |
| // sleep for 100 ms before next attempt |
| usleep(100000); |
| } |
| |
| // setup key parameters to send to Ducati during init |
| OMX_CALLBACKTYPE oCallbacks = callbacks; |
| |
| // get handle |
| eError = OMX_GetHandle(handle, (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA", pAppData, &oCallbacks); |
| if ( eError == OMX_ErrorNone ) { |
| return OMX_ErrorNone; |
| } |
| |
| CAMHAL_LOGEB("OMX_GetHandle() failed, error: 0x%x", eError); |
| } |
| |
| *handle = 0; |
| return eError; |
| } |
| |
| |
| class CapabilitiesHandler |
| { |
| public: |
| CapabilitiesHandler() |
| { |
| mComponent = 0; |
| } |
| |
| const OMX_HANDLETYPE & component() const |
| { |
| return mComponent; |
| } |
| |
| OMX_HANDLETYPE & componentRef() |
| { |
| return mComponent; |
| } |
| |
| status_t fetchCapabiltiesForMode(OMX_CAMOPERATINGMODETYPE mode, |
| int sensorId, |
| CameraProperties::Properties * properties) |
| { |
| OMX_CONFIG_CAMOPERATINGMODETYPE camMode; |
| |
| OMX_INIT_STRUCT_PTR (&camMode, OMX_CONFIG_CAMOPERATINGMODETYPE); |
| camMode.eCamOperatingMode = mode; |
| |
| OMX_ERRORTYPE eError = OMX_SetParameter(component(), |
| ( OMX_INDEXTYPE ) OMX_IndexCameraOperatingMode, |
| &camMode); |
| |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGE("Error while configuring camera mode in CameraAdapter_Capabilities 0x%x", eError); |
| return BAD_VALUE; |
| } |
| |
| // get and fill capabilities |
| OMXCameraAdapter::getCaps(sensorId, properties, component()); |
| |
| return NO_ERROR; |
| } |
| |
| status_t fetchCapabilitiesForSensor(int sensorId, |
| CameraProperties::Properties * properties) |
| { |
| // sensor select |
| OMX_CONFIG_SENSORSELECTTYPE sensorSelect; |
| OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE); |
| sensorSelect.eSensor = (OMX_SENSORSELECT)sensorId; |
| |
| CAMHAL_LOGD("Selecting sensor %d...", sensorId); |
| const OMX_ERRORTYPE sensorSelectError = OMX_SetConfig(component(), |
| (OMX_INDEXTYPE)OMX_TI_IndexConfigSensorSelect, &sensorSelect); |
| CAMHAL_LOGD("Selecting sensor %d... DONE", sensorId); |
| |
| if ( sensorSelectError != OMX_ErrorNone ) { |
| CAMHAL_LOGD("Max supported sensor number reached: %d", sensorId); |
| return BAD_VALUE; |
| } |
| |
| status_t err = NO_ERROR; |
| if ( sensorId == 2 ) { |
| CAMHAL_LOGD("Camera mode: STEREO"); |
| properties->setMode(MODE_STEREO); |
| err = fetchCapabiltiesForMode(OMX_CaptureStereoImageCapture, |
| sensorId, |
| properties); |
| } else { |
| CAMHAL_LOGD("Camera MONO"); |
| |
| CAMHAL_LOGD("Camera mode: HQ "); |
| properties->setMode(MODE_HIGH_QUALITY); |
| err = fetchCapabiltiesForMode(OMX_CaptureImageProfileBase, |
| sensorId, |
| properties); |
| if ( NO_ERROR != err ) { |
| return err; |
| } |
| |
| CAMHAL_LOGD("Camera mode: VIDEO "); |
| properties->setMode(MODE_VIDEO); |
| err = fetchCapabiltiesForMode(OMX_CaptureVideo, |
| sensorId, |
| properties); |
| if ( NO_ERROR != err ) { |
| return err; |
| } |
| |
| CAMHAL_LOGD("Camera mode: ZSL "); |
| properties->setMode(MODE_ZEROSHUTTERLAG); |
| err = fetchCapabiltiesForMode(OMX_TI_CaptureImageProfileZeroShutterLag, |
| sensorId, |
| properties); |
| if ( NO_ERROR != err ) { |
| return err; |
| } |
| |
| CAMHAL_LOGD("Camera mode: HS "); |
| properties->setMode(MODE_HIGH_SPEED); |
| err = fetchCapabiltiesForMode(OMX_CaptureImageHighSpeedTemporalBracketing, |
| sensorId, |
| properties); |
| if ( NO_ERROR != err ) { |
| return err; |
| } |
| |
| CAMHAL_LOGD("Camera mode: CPCAM "); |
| properties->setMode(MODE_CPCAM); |
| err = fetchCapabiltiesForMode(OMX_TI_CPCam, |
| sensorId, |
| properties); |
| if ( NO_ERROR != err ) { |
| return err; |
| } |
| |
| #ifdef CAMERAHAL_OMAP5_CAPTURE_MODES |
| |
| CAMHAL_LOGD("Camera mode: VIDEO HQ "); |
| properties->setMode(MODE_VIDEO_HIGH_QUALITY); |
| err = fetchCapabiltiesForMode(OMX_CaptureHighQualityVideo, |
| sensorId, |
| properties); |
| if ( NO_ERROR != err ) { |
| return err; |
| } |
| |
| #endif |
| |
| } |
| |
| return err; |
| } |
| |
| private: |
| OMX_HANDLETYPE mComponent; |
| OMX_STATETYPE mState; |
| }; |
| |
| extern "C" status_t OMXCameraAdapter_Capabilities( |
| CameraProperties::Properties * const properties_array, |
| const int starting_camera, const int max_camera, int & supportedCameras) |
| { |
| LOG_FUNCTION_NAME; |
| |
| supportedCameras = 0; |
| |
| int num_cameras_supported = 0; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| android::AutoMutex lock(gAdapterLock); |
| |
| if (!properties_array) { |
| CAMHAL_LOGEB("invalid param: properties = 0x%p", properties_array); |
| LOG_FUNCTION_NAME_EXIT; |
| return BAD_VALUE; |
| } |
| |
| eError = OMX_Init(); |
| if (eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("Error OMX_Init -0x%x", eError); |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| CapabilitiesHandler handler; |
| OMX_CALLBACKTYPE callbacks; |
| callbacks.EventHandler = 0; |
| callbacks.EmptyBufferDone = 0; |
| callbacks.FillBufferDone = 0; |
| |
| eError = OMXCameraAdapter::OMXCameraGetHandle(&handler.componentRef(), &handler, callbacks); |
| if (eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError); |
| goto EXIT; |
| } |
| |
| DCCHandler dcc_handler; |
| dcc_handler.loadDCC(handler.componentRef()); |
| |
| // Continue selecting sensor and then querying OMX Camera for it's capabilities |
| // When sensor select returns an error, we know to break and stop |
| while (eError == OMX_ErrorNone && |
| (starting_camera + num_cameras_supported) < max_camera) { |
| |
| const int sensorId = num_cameras_supported; |
| CameraProperties::Properties * properties = properties_array + starting_camera + sensorId; |
| const status_t err = handler.fetchCapabilitiesForSensor(sensorId, properties); |
| |
| if ( err != NO_ERROR ) |
| break; |
| |
| num_cameras_supported++; |
| CAMHAL_LOGEB("Number of OMX Cameras detected = %d \n",num_cameras_supported); |
| } |
| |
| // clean up |
| if(handler.component()) { |
| CAMHAL_LOGD("Freeing the component..."); |
| OMX_FreeHandle(handler.component()); |
| CAMHAL_LOGD("Freeing the component... DONE"); |
| handler.componentRef() = NULL; |
| } |
| |
| EXIT: |
| CAMHAL_LOGD("Deinit..."); |
| OMX_Deinit(); |
| CAMHAL_LOGD("Deinit... DONE"); |
| |
| if ( eError != OMX_ErrorNone ) |
| { |
| CAMHAL_LOGE("Error: 0x%x", eError); |
| LOG_FUNCTION_NAME_EXIT; |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| supportedCameras = num_cameras_supported; |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return NO_ERROR; |
| } |
| |
| } // namespace Camera |
| } // namespace Ti |
| |
| |
| /*--------------------Camera Adapter Class ENDS here-----------------------------*/ |
| |
