| /* |
| * 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 OMXCapture.cpp |
| * |
| * This file contains functionality for handling image capture. |
| * |
| */ |
| |
| #include "CameraHal.h" |
| #include "OMXCameraAdapter.h" |
| #include "ErrorUtils.h" |
| |
| |
| namespace Ti { |
| namespace Camera { |
| |
| status_t OMXCameraAdapter::setParametersCapture(const android::CameraParameters ¶ms, |
| BaseCameraAdapter::AdapterState state) |
| { |
| status_t ret = NO_ERROR; |
| const char *str = NULL; |
| int w, h; |
| OMX_COLOR_FORMATTYPE pixFormat; |
| CodingMode codingMode = mCodingMode; |
| const char *valstr = NULL; |
| int varint = 0; |
| OMX_TI_STEREOFRAMELAYOUTTYPE capFrmLayout; |
| bool inCaptureState = false; |
| |
| LOG_FUNCTION_NAME; |
| |
| OMXCameraPortParameters *cap; |
| cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| |
| capFrmLayout = cap->mFrameLayoutType; |
| setParamS3D(mCameraAdapterParameters.mImagePortIndex, |
| params.get(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT)); |
| if (capFrmLayout != cap->mFrameLayoutType) { |
| mPendingCaptureSettings |= SetFormat; |
| } |
| |
| params.getPictureSize(&w, &h); |
| |
| if ( ( w != ( int ) cap->mWidth ) || |
| ( h != ( int ) cap->mHeight ) ) |
| { |
| mPendingCaptureSettings |= SetFormat; |
| } |
| |
| cap->mWidth = w; |
| cap->mHeight = h; |
| //TODO: Support more pixelformats |
| //cap->mStride = 2; |
| |
| CAMHAL_LOGVB("Image: cap.mWidth = %d", (int)cap->mWidth); |
| CAMHAL_LOGVB("Image: cap.mHeight = %d", (int)cap->mHeight); |
| |
| if ((valstr = params.getPictureFormat()) != NULL) { |
| if (strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_YUV422I) == 0) { |
| CAMHAL_LOGDA("CbYCrY format selected"); |
| pixFormat = OMX_COLOR_FormatCbYCrY; |
| mPictureFormatFromClient = android::CameraParameters::PIXEL_FORMAT_YUV422I; |
| } else if(strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) { |
| CAMHAL_LOGDA("YUV420SP format selected"); |
| pixFormat = OMX_COLOR_FormatYUV420SemiPlanar; |
| mPictureFormatFromClient = android::CameraParameters::PIXEL_FORMAT_YUV420SP; |
| } else if(strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_RGB565) == 0) { |
| CAMHAL_LOGDA("RGB565 format selected"); |
| pixFormat = OMX_COLOR_Format16bitRGB565; |
| mPictureFormatFromClient = android::CameraParameters::PIXEL_FORMAT_RGB565; |
| } else if (strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_JPEG) == 0) { |
| CAMHAL_LOGDA("JPEG format selected"); |
| pixFormat = OMX_COLOR_FormatUnused; |
| codingMode = CodingJPEG; |
| mPictureFormatFromClient = android::CameraParameters::PIXEL_FORMAT_JPEG; |
| } else if (strcmp(valstr, TICameraParameters::PIXEL_FORMAT_JPS) == 0) { |
| CAMHAL_LOGDA("JPS format selected"); |
| pixFormat = OMX_COLOR_FormatUnused; |
| codingMode = CodingJPS; |
| mPictureFormatFromClient = TICameraParameters::PIXEL_FORMAT_JPS; |
| } else if (strcmp(valstr, TICameraParameters::PIXEL_FORMAT_MPO) == 0) { |
| CAMHAL_LOGDA("MPO format selected"); |
| pixFormat = OMX_COLOR_FormatUnused; |
| codingMode = CodingMPO; |
| mPictureFormatFromClient = TICameraParameters::PIXEL_FORMAT_MPO; |
| } else if (strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_BAYER_RGGB) == 0) { |
| CAMHAL_LOGDA("RAW Picture format selected"); |
| pixFormat = OMX_COLOR_FormatRawBayer10bit; |
| mPictureFormatFromClient = android::CameraParameters::PIXEL_FORMAT_BAYER_RGGB; |
| } else { |
| CAMHAL_LOGEA("Invalid format, JPEG format selected as default"); |
| pixFormat = OMX_COLOR_FormatUnused; |
| codingMode = CodingJPEG; |
| mPictureFormatFromClient = NULL; |
| } |
| } else { |
| CAMHAL_LOGEA("Picture format is NULL, defaulting to JPEG"); |
| pixFormat = OMX_COLOR_FormatUnused; |
| codingMode = CodingJPEG; |
| mPictureFormatFromClient = NULL; |
| } |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| mRawCapture = false; |
| mYuvCapture = false; |
| |
| valstr = params.get(TICameraParameters::KEY_CAP_MODE); |
| if ( (!valstr || strcmp(valstr, TICameraParameters::HIGH_QUALITY_MODE) == 0) && |
| access(kRawImagesOutputDirPath, F_OK) != -1 ) { |
| mRawCapture = true; |
| } |
| |
| if (mRawCapture && (access(kYuvImagesOutputDirPath, F_OK) != -1)) { |
| pixFormat = OMX_COLOR_FormatCbYCrY; |
| mYuvCapture = true; |
| } |
| #endif |
| // JPEG capture is not supported in video mode by OMX Camera |
| // Set capture format to yuv422i...jpeg encode will |
| // be done on A9 |
| valstr = params.get(TICameraParameters::KEY_CAP_MODE); |
| if ( (valstr && ( strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0 || |
| strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE_HQ) == 0 ) ) && |
| (pixFormat == OMX_COLOR_FormatUnused) ) { |
| CAMHAL_LOGDA("Capturing in video mode...selecting yuv422i"); |
| pixFormat = OMX_COLOR_FormatCbYCrY; |
| } |
| |
| if (pixFormat != cap->mColorFormat || codingMode != mCodingMode) { |
| mPendingCaptureSettings |= SetFormat; |
| cap->mColorFormat = pixFormat; |
| mCodingMode = codingMode; |
| } |
| |
| #ifdef OMAP_ENHANCEMENT |
| str = params.get(TICameraParameters::KEY_TEMP_BRACKETING); |
| if ( ( str != NULL ) && |
| ( strcmp(str, android::CameraParameters::TRUE) == 0 ) ) { |
| |
| if ( !mBracketingSet ) { |
| mPendingCaptureSettings |= SetBurstExpBracket; |
| } |
| |
| mBracketingSet = true; |
| } else { |
| |
| if ( mBracketingSet ) { |
| mPendingCaptureSettings |= SetBurstExpBracket; |
| } |
| |
| mBracketingSet = false; |
| } |
| |
| if ( (str = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL ) { |
| parseExpRange(str, mExposureBracketingValues, NULL, |
| mExposureGainBracketingModes, |
| EXP_BRACKET_RANGE, mExposureBracketingValidEntries); |
| if (mCapMode == OMXCameraAdapter::CP_CAM) { |
| mExposureBracketMode = OMX_BracketVectorShot; |
| } else { |
| mExposureBracketMode = OMX_BracketExposureRelativeInEV; |
| } |
| mPendingCaptureSettings |= SetBurstExpBracket; |
| } else if ( (str = params.get(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE)) != NULL) { |
| parseExpRange(str, mExposureBracketingValues, mExposureGainBracketingValues, |
| mExposureGainBracketingModes, |
| EXP_BRACKET_RANGE, mExposureBracketingValidEntries); |
| if (mCapMode == OMXCameraAdapter::CP_CAM) { |
| mExposureBracketMode = OMX_BracketVectorShot; |
| } else { |
| mExposureBracketMode = OMX_BracketExposureGainAbsolute; |
| } |
| mPendingCaptureSettings |= SetBurstExpBracket; |
| } else { |
| // always set queued shot config in CPCAM mode |
| if (mCapMode == OMXCameraAdapter::CP_CAM) { |
| mExposureBracketMode = OMX_BracketVectorShot; |
| mPendingCaptureSettings |= SetBurstExpBracket; |
| } |
| // if bracketing was previously set...we set again before capturing to clear |
| if (mExposureBracketingValidEntries) { |
| mPendingCaptureSettings |= SetBurstExpBracket; |
| mExposureBracketingValidEntries = 0; |
| } |
| } |
| |
| str = params.get(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE); |
| if ( NULL != str ) { |
| parseExpRange(str, mZoomBracketingValues, NULL, NULL, |
| ZOOM_BRACKET_RANGE, mZoomBracketingValidEntries); |
| mCurrentZoomBracketing = 0; |
| mZoomBracketingEnabled = true; |
| } else { |
| if (mZoomBracketingValidEntries) { |
| mZoomBracketingValidEntries = 0; |
| } |
| mZoomBracketingEnabled = false; |
| } |
| #endif |
| |
| // Flush config queue |
| // If TRUE: Flush queue and abort processing before enqueing |
| valstr = params.get(TICameraParameters::KEY_FLUSH_SHOT_CONFIG_QUEUE); |
| if ( NULL != valstr ) { |
| if ( 0 == strcmp(valstr, android::CameraParameters::TRUE) ) { |
| mFlushShotConfigQueue = true; |
| } else if ( 0 == strcmp(valstr, android::CameraParameters::FALSE) ) { |
| mFlushShotConfigQueue = false; |
| } else { |
| CAMHAL_LOGE("Missing flush shot config parameter. Will use current (%s)", |
| mFlushShotConfigQueue ? "true" : "false"); |
| } |
| } |
| |
| if ( params.getInt(android::CameraParameters::KEY_ROTATION) != -1 ) |
| { |
| if (params.getInt(android::CameraParameters::KEY_ROTATION) != (int) mPictureRotation) { |
| mPendingCaptureSettings |= SetRotation; |
| } |
| mPictureRotation = params.getInt(android::CameraParameters::KEY_ROTATION); |
| } |
| else |
| { |
| if (mPictureRotation) mPendingCaptureSettings |= SetRotation; |
| mPictureRotation = 0; |
| } |
| |
| CAMHAL_LOGVB("Picture Rotation set %d", mPictureRotation); |
| |
| #ifdef OMAP_ENHANCEMENT |
| // Read Sensor Orientation and set it based on perating mode |
| varint = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION); |
| if ( varint != -1 ) |
| { |
| mSensorOrientation = varint; |
| if (mSensorOrientation == 270 ||mSensorOrientation==90) |
| { |
| CAMHAL_LOGEA(" Orientation is 270/90. So setting counter rotation to Ducati"); |
| mSensorOrientation +=180; |
| mSensorOrientation%=360; |
| } |
| } |
| else |
| { |
| mSensorOrientation = 0; |
| } |
| |
| CAMHAL_LOGVB("Sensor Orientation set : %d", mSensorOrientation); |
| #endif |
| |
| #ifdef OMAP_ENHANCEMENT_BURST_CAPTURE |
| varint = params.getInt(TICameraParameters::KEY_BURST); |
| if ( varint >= 1 ) |
| { |
| if (varint != (int) mBurstFrames) { |
| mPendingCaptureSettings |= SetBurstExpBracket; |
| } |
| mBurstFrames = varint; |
| } |
| else |
| { |
| if (mBurstFrames != 1) mPendingCaptureSettings |= SetBurstExpBracket; |
| mBurstFrames = 1; |
| } |
| |
| CAMHAL_LOGVB("Burst Frames set %d", mBurstFrames); |
| #endif |
| |
| varint = params.getInt(android::CameraParameters::KEY_JPEG_QUALITY); |
| if ( varint >= MIN_JPEG_QUALITY && varint <= MAX_JPEG_QUALITY ) { |
| if (varint != mPictureQuality) { |
| mPendingCaptureSettings |= SetQuality; |
| mPictureQuality = varint; |
| } |
| } else { |
| if (mPictureQuality != MAX_JPEG_QUALITY) { |
| mPendingCaptureSettings |= SetQuality; |
| mPictureQuality = MAX_JPEG_QUALITY; |
| } |
| } |
| |
| CAMHAL_LOGVB("Picture Quality set %d", mPictureQuality); |
| |
| varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); |
| if ( varint >= 0 ) { |
| if (varint != mThumbWidth) { |
| mPendingCaptureSettings |= SetThumb; |
| mThumbWidth = varint; |
| } |
| } else { |
| if (mThumbWidth != DEFAULT_THUMB_WIDTH) { |
| mPendingCaptureSettings |= SetThumb; |
| mThumbWidth = DEFAULT_THUMB_WIDTH; |
| } |
| } |
| |
| CAMHAL_LOGVB("Picture Thumb width set %d", mThumbWidth); |
| |
| varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); |
| if ( varint >= 0 ) { |
| if (varint != mThumbHeight) { |
| mPendingCaptureSettings |= SetThumb; |
| mThumbHeight = varint; |
| } |
| } else { |
| if (mThumbHeight != DEFAULT_THUMB_HEIGHT) { |
| mPendingCaptureSettings |= SetThumb; |
| mThumbHeight = DEFAULT_THUMB_HEIGHT; |
| } |
| } |
| |
| CAMHAL_LOGVB("Picture Thumb height set %d", mThumbHeight); |
| |
| varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); |
| if ( varint >= MIN_JPEG_QUALITY && varint <= MAX_JPEG_QUALITY ) { |
| if (varint != mThumbQuality) { |
| mPendingCaptureSettings |= SetThumb; |
| mThumbQuality = varint; |
| } |
| } else { |
| if (mThumbQuality != MAX_JPEG_QUALITY) { |
| mPendingCaptureSettings |= SetThumb; |
| mThumbQuality = MAX_JPEG_QUALITY; |
| } |
| } |
| |
| CAMHAL_LOGDB("Thumbnail Quality set %d", mThumbQuality); |
| |
| if (mFirstTimeInit) { |
| mPendingCaptureSettings = ECapturesettingsAll; |
| } |
| |
| cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex]; |
| cap->mWidth = params.getInt(TICameraParameters::RAW_WIDTH); |
| cap->mHeight = params.getInt(TICameraParameters::RAW_HEIGHT); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::getPictureBufferSize(CameraFrame &frame, size_t bufferCount) |
| { |
| status_t ret = NO_ERROR; |
| OMXCameraPortParameters *imgCaptureData = NULL; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( NO_ERROR == ret ) |
| { |
| imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| |
| |
| // If any settings have changed that need to be set with SetParam, |
| // we will need to disable the port to set them |
| if ((mPendingCaptureSettings & ECaptureParamSettings)) { |
| disableImagePort(); |
| if ( NULL != mReleaseImageBuffersCallback ) { |
| mReleaseImageBuffersCallback(mReleaseData); |
| } |
| } |
| |
| if (mPendingCaptureSettings & SetFormat) { |
| ret = setFormat(OMX_CAMERA_PORT_IMAGE_OUT_IMAGE, *imgCaptureData); |
| } |
| |
| if ( ret == NO_ERROR ) |
| { |
| frame.mLength = imgCaptureData->mBufSize; |
| frame.mWidth = imgCaptureData->mWidth; |
| frame.mHeight = imgCaptureData->mHeight; |
| frame.mAlignment = imgCaptureData->mStride; |
| CAMHAL_LOGDB("getPictureBufferSize: width:%u height:%u alignment:%u length:%u", |
| frame.mWidth, frame.mHeight, frame.mAlignment, frame.mLength); |
| } |
| else |
| { |
| CAMHAL_LOGEB("setFormat() failed 0x%x", ret); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| int OMXCameraAdapter::getBracketingValueMode(const char *a, const char *b) const |
| { |
| BracketingValueMode bvm = BracketingValueAbsolute; |
| |
| if ( (NULL != b) && |
| (NULL != a) && |
| (a < b) && |
| ( (NULL != memchr(a, '+', b - a)) || |
| (NULL != memchr(a, '-', b - a)) ) ) { |
| bvm = BracketingValueRelative; |
| } |
| return bvm; |
| } |
| |
| status_t OMXCameraAdapter::parseExpRange(const char *rangeStr, |
| int *expRange, |
| int *gainRange, |
| int *expGainModes, |
| size_t count, |
| size_t &validEntries) |
| { |
| status_t ret = NO_ERROR; |
| char *end = NULL; |
| const char *startPtr = NULL; |
| size_t i = 0; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( NULL == rangeStr ){ |
| return -EINVAL; |
| } |
| |
| if ( NULL == expRange ){ |
| return -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) { |
| startPtr = rangeStr; |
| do { |
| // Relative Exposure example: "-30,-10, 0, 10, 30" |
| // Absolute Gain ex. (exposure,gain) pairs: "(100,300),(200,300),(400,300),(800,300),(1600,300)" |
| // Relative Gain ex. (exposure,gain) pairs: "(-30,+0),(-10, +0),(+0,+0),(+10,+0),(+30,+0)" |
| // Forced relative Exposure example: "-30F,-10F, 0F, 10F, 30F" |
| // Forced absolute Gain ex. (exposure,gain) pairs: "(100,300)F,(200,300)F,(400,300)F,(800,300)F,(1600,300)F" |
| // Forced relative Gain ex. (exposure,gain) pairs: "(-30,+0)F,(-10, +0)F,(+0,+0)F,(+10,+0)F,(+30,+0)F" |
| |
| // skip '(' and ',' |
| while ((*startPtr == '(') || (*startPtr == ',')) startPtr++; |
| |
| expRange[i] = (int)strtol(startPtr, &end, 10); |
| |
| if (expGainModes) { |
| // if gainRange is given rangeStr should be (exposure, gain) pair |
| if (gainRange) { |
| int bvm_exp = getBracketingValueMode(startPtr, end); |
| startPtr = end + 1; // for the ',' |
| gainRange[i] = (int)strtol(startPtr, &end, 10); |
| |
| if (BracketingValueAbsolute == bvm_exp) { |
| expGainModes[i] = getBracketingValueMode(startPtr, end); |
| } else { |
| expGainModes[i] = bvm_exp; |
| } |
| } else { |
| expGainModes[i] = BracketingValueCompensation; |
| } |
| } |
| startPtr = end; |
| |
| // skip ')' |
| while (*startPtr == ')') startPtr++; |
| |
| // Check for "forced" key |
| if (expGainModes) { |
| while ((*startPtr == 'F') || (*startPtr == 'f')) { |
| if ( BracketingValueAbsolute == expGainModes[i] ) { |
| expGainModes[i] = BracketingValueAbsoluteForced; |
| } else if ( BracketingValueRelative == expGainModes[i] ) { |
| expGainModes[i] = BracketingValueRelativeForced; |
| } else if ( BracketingValueCompensation == expGainModes[i] ) { |
| expGainModes[i] = BracketingValueCompensationForced; |
| } else { |
| CAMHAL_LOGE("Unexpected old mode 0x%x", expGainModes[i]); |
| } |
| startPtr++; |
| } |
| } |
| |
| i++; |
| |
| } while ((startPtr[0] != '\0') && (i < count)); |
| validEntries = i; |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::doExposureBracketing(int *evValues, |
| int *evValues2, |
| int *evModes2, |
| size_t evCount, |
| size_t frameCount, |
| bool flush, |
| OMX_BRACKETMODETYPE bracketMode) |
| { |
| status_t ret = NO_ERROR; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NULL == evValues ) { |
| CAMHAL_LOGEA("Exposure compensation values pointer is invalid"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) { |
| if (bracketMode == OMX_BracketVectorShot) { |
| ret = setVectorShot(evValues, evValues2, evModes2, evCount, frameCount, flush, bracketMode); |
| } else { |
| ret = setExposureBracketing(evValues, evValues2, evCount, frameCount, bracketMode); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setVectorStop(bool toPreview) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_CONFIG_VECTSHOTSTOPMETHODTYPE vecShotStop; |
| |
| |
| LOG_FUNCTION_NAME; |
| |
| OMX_INIT_STRUCT_PTR(&vecShotStop, OMX_TI_CONFIG_VECTSHOTSTOPMETHODTYPE); |
| |
| vecShotStop.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| if (toPreview) { |
| vecShotStop.eStopMethod = OMX_TI_VECTSHOTSTOPMETHOD_GOTO_PREVIEW; |
| } else { |
| vecShotStop.eStopMethod = OMX_TI_VECTSHOTSTOPMETHOD_WAIT_IN_CAPTURE; |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigVectShotStopMethod, |
| &vecShotStop); |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while configuring bracket shot 0x%x", eError); |
| } else { |
| CAMHAL_LOGDA("Bracket shot configured successfully"); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::initVectorShot() |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_CAPTUREMODETYPE expCapMode; |
| OMX_CONFIG_EXTCAPTUREMODETYPE extExpCapMode; |
| |
| LOG_FUNCTION_NAME; |
| |
| if (NO_ERROR == ret) { |
| OMX_INIT_STRUCT_PTR (&expCapMode, OMX_CONFIG_CAPTUREMODETYPE); |
| expCapMode.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| |
| expCapMode.bFrameLimited = OMX_FALSE; |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCaptureMode, |
| &expCapMode); |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while configuring capture mode 0x%x", eError); |
| goto exit; |
| } else { |
| CAMHAL_LOGDA("Camera capture mode configured successfully"); |
| } |
| } |
| |
| if (NO_ERROR == ret) { |
| OMX_INIT_STRUCT_PTR (&extExpCapMode, OMX_CONFIG_EXTCAPTUREMODETYPE); |
| extExpCapMode.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| |
| extExpCapMode.bEnableBracketing = OMX_TRUE; |
| extExpCapMode.tBracketConfigType.eBracketMode = OMX_BracketVectorShot; |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexConfigExtCaptureMode, |
| &extExpCapMode); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring extended capture mode 0x%x", eError); |
| goto exit; |
| } else { |
| CAMHAL_LOGDA("Extended camera capture mode configured successfully"); |
| } |
| } |
| |
| |
| if (NO_ERROR == ret) { |
| // set vector stop method to stop in capture |
| ret = setVectorStop(false); |
| } |
| |
| exit: |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::setVectorShot(int *evValues, |
| int *evValues2, |
| int *evModes2, |
| size_t evCount, |
| size_t frameCount, |
| bool flush, |
| OMX_BRACKETMODETYPE bracketMode) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_CONFIG_ENQUEUESHOTCONFIGS enqueueShotConfigs; |
| OMX_TI_CONFIG_QUERYAVAILABLESHOTS queryAvailableShots; |
| bool doFlush = flush; |
| |
| LOG_FUNCTION_NAME; |
| |
| OMX_INIT_STRUCT_PTR(&enqueueShotConfigs, OMX_TI_CONFIG_ENQUEUESHOTCONFIGS); |
| OMX_INIT_STRUCT_PTR(&queryAvailableShots, OMX_TI_CONFIG_QUERYAVAILABLESHOTS); |
| |
| queryAvailableShots.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigQueryAvailableShots, |
| &queryAvailableShots); |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGE("Error getting available shots 0x%x", eError); |
| goto exit; |
| } else { |
| CAMHAL_LOGD("AVAILABLE SHOTS: %d", queryAvailableShots.nAvailableShots); |
| if (queryAvailableShots.nAvailableShots < evCount) { |
| // TODO(XXX): Need to implement some logic to handle this error |
| CAMHAL_LOGE("Not enough available shots to fulfill this queue request"); |
| ret = -ENOSPC; |
| goto exit; |
| } |
| } |
| |
| for ( unsigned int confID = 0; confID < evCount; ) { |
| unsigned int i; |
| for ( i = 0 ; (i < ARRAY_SIZE(enqueueShotConfigs.nShotConfig)) && (confID < evCount); i++, confID++ ) { |
| CAMHAL_LOGD("%2u: (%7d,%4d) mode: %d", confID, evValues[confID], evValues2[confID], evModes2[confID]); |
| enqueueShotConfigs.nShotConfig[i].nConfigId = confID; |
| enqueueShotConfigs.nShotConfig[i].nFrames = 1; |
| if ( (BracketingValueCompensation == evModes2[confID]) || |
| (BracketingValueCompensationForced == evModes2[confID]) ) { |
| // EV compensation |
| enqueueShotConfigs.nShotConfig[i].nEC = evValues[confID]; |
| enqueueShotConfigs.nShotConfig[i].nExp = 0; |
| enqueueShotConfigs.nShotConfig[i].nGain = 0; |
| } else { |
| // exposure,gain pair |
| enqueueShotConfigs.nShotConfig[i].nEC = 0; |
| enqueueShotConfigs.nShotConfig[i].nExp = evValues[confID]; |
| enqueueShotConfigs.nShotConfig[i].nGain = evValues2[confID]; |
| } |
| enqueueShotConfigs.nShotConfig[i].eExpGainApplyMethod = OMX_TI_EXPGAINAPPLYMETHOD_ABSOLUTE; |
| switch (evModes2[confID]) { |
| case BracketingValueAbsolute: // (exp,gain) pairs directly program sensor values |
| default : |
| enqueueShotConfigs.nShotConfig[i].eExpGainApplyMethod = OMX_TI_EXPGAINAPPLYMETHOD_ABSOLUTE; |
| break; |
| case BracketingValueRelative: // (exp,gain) pairs relative to AE settings and constraints |
| case BracketingValueCompensation: // EV compensation relative to AE settings and constraints |
| enqueueShotConfigs.nShotConfig[i].eExpGainApplyMethod = OMX_TI_EXPGAINAPPLYMETHOD_RELATIVE; |
| break; |
| case BracketingValueAbsoluteForced: // (exp,gain) pairs directly program sensor values |
| // are forced over constraints due to flicker, etc. |
| enqueueShotConfigs.nShotConfig[i].eExpGainApplyMethod = OMX_TI_EXPGAINAPPLYMETHOD_FORCE_ABSOLUTE; |
| break; |
| case BracketingValueRelativeForced: // (exp, gain) pairs relative to AE settings AND settings |
| case BracketingValueCompensationForced: // EV compensation relative to AE settings and constraints |
| // are forced over constraints due to flicker, etc. |
| enqueueShotConfigs.nShotConfig[i].eExpGainApplyMethod = OMX_TI_EXPGAINAPPLYMETHOD_FORCE_RELATIVE; |
| break; |
| } |
| enqueueShotConfigs.nShotConfig[i].bNoSnapshot = OMX_FALSE; // TODO: Make this configurable |
| } |
| |
| // Repeat last exposure and again |
| if ((confID == evCount) && (evCount > 0) && (frameCount > evCount) && (0 != i)) { |
| enqueueShotConfigs.nShotConfig[i-1].nFrames = frameCount - evCount; |
| } |
| |
| enqueueShotConfigs.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| enqueueShotConfigs.bFlushQueue = doFlush ? OMX_TRUE : OMX_FALSE; |
| enqueueShotConfigs.nNumConfigs = i; |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigEnqueueShotConfigs, |
| &enqueueShotConfigs); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring enqueue shot 0x%x", eError); |
| goto exit; |
| } else { |
| CAMHAL_LOGDA("Enqueue shot configured successfully"); |
| } |
| // Flush only first time |
| doFlush = false; |
| } |
| |
| // Handle burst capture (no any bracketing) case |
| if (0 == evCount) { |
| CAMHAL_LOGE("Handle burst capture (no any bracketing) case"); |
| enqueueShotConfigs.nShotConfig[0].nConfigId = 0; |
| enqueueShotConfigs.nShotConfig[0].nFrames = frameCount; |
| enqueueShotConfigs.nShotConfig[0].nEC = 0; |
| enqueueShotConfigs.nShotConfig[0].nExp = 0; |
| enqueueShotConfigs.nShotConfig[0].nGain = 0; |
| enqueueShotConfigs.nShotConfig[0].eExpGainApplyMethod = OMX_TI_EXPGAINAPPLYMETHOD_RELATIVE; |
| enqueueShotConfigs.nShotConfig[0].bNoSnapshot = OMX_FALSE; // TODO: Make this configurable |
| enqueueShotConfigs.nNumConfigs = 1; |
| enqueueShotConfigs.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| enqueueShotConfigs.bFlushQueue = doFlush ? OMX_TRUE : OMX_FALSE; |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigEnqueueShotConfigs, |
| &enqueueShotConfigs); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring enqueue shot 0x%x", eError); |
| goto exit; |
| } else { |
| CAMHAL_LOGDA("Enqueue shot configured successfully"); |
| } |
| } |
| |
| exit: |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::setExposureBracketing(int *evValues, |
| int *evValues2, |
| size_t evCount, |
| size_t frameCount, |
| OMX_BRACKETMODETYPE bracketMode) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_CAPTUREMODETYPE expCapMode; |
| OMX_CONFIG_EXTCAPTUREMODETYPE extExpCapMode; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&expCapMode, OMX_CONFIG_CAPTUREMODETYPE); |
| expCapMode.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| |
| /// If frameCount>0 but evCount<=0, then this is the case of HQ burst. |
| //Otherwise, it is normal HQ capture |
| ///If frameCount>0 and evCount>0 then this is the cause of HQ Exposure bracketing. |
| if ( 0 == evCount && 0 == frameCount ) |
| { |
| expCapMode.bFrameLimited = OMX_FALSE; |
| } |
| else |
| { |
| expCapMode.bFrameLimited = OMX_TRUE; |
| expCapMode.nFrameLimit = frameCount; |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCaptureMode, |
| &expCapMode); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring capture mode 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Camera capture mode configured successfully"); |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&extExpCapMode, OMX_CONFIG_EXTCAPTUREMODETYPE); |
| extExpCapMode.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| |
| if ( 0 == evCount ) |
| { |
| extExpCapMode.bEnableBracketing = OMX_FALSE; |
| } |
| else |
| { |
| extExpCapMode.bEnableBracketing = OMX_TRUE; |
| extExpCapMode.tBracketConfigType.eBracketMode = bracketMode; |
| extExpCapMode.tBracketConfigType.nNbrBracketingValues = evCount - 1; |
| } |
| |
| for ( unsigned int i = 0 ; i < evCount ; i++ ) |
| { |
| if (bracketMode == OMX_BracketExposureGainAbsolute) { |
| extExpCapMode.tBracketConfigType.nBracketValues[i] = evValues[i]; |
| extExpCapMode.tBracketConfigType.nBracketValues2[i] = evValues2[i]; |
| } else { |
| // assuming OMX_BracketExposureRelativeInEV |
| extExpCapMode.tBracketConfigType.nBracketValues[i] = ( evValues[i] * ( 1 << Q16_OFFSET ) ) / 10; |
| } |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexConfigExtCaptureMode, |
| &extExpCapMode); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring extended capture mode 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Extended camera capture mode configured successfully"); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setShutterCallback(bool enabled) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_CALLBACKREQUESTTYPE shutterRequstCallback; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateExecuting != mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component not in executing state"); |
| ret = -1; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| |
| OMX_INIT_STRUCT_PTR (&shutterRequstCallback, OMX_CONFIG_CALLBACKREQUESTTYPE); |
| shutterRequstCallback.nPortIndex = OMX_ALL; |
| |
| if ( enabled ) |
| { |
| shutterRequstCallback.bEnable = OMX_TRUE; |
| shutterRequstCallback.nIndex = ( OMX_INDEXTYPE ) OMX_TI_IndexConfigShutterCallback; |
| CAMHAL_LOGDA("Enabling shutter callback"); |
| } |
| else |
| { |
| shutterRequstCallback.bEnable = OMX_FALSE; |
| shutterRequstCallback.nIndex = ( OMX_INDEXTYPE ) OMX_TI_IndexConfigShutterCallback; |
| CAMHAL_LOGDA("Disabling shutter callback"); |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexConfigCallbackRequest, |
| &shutterRequstCallback); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error registering shutter callback 0x%x", eError); |
| ret = -1; |
| } |
| else |
| { |
| CAMHAL_LOGDB("Shutter callback for index 0x%x registered successfully", |
| OMX_TI_IndexConfigShutterCallback); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::doBracketing(OMX_BUFFERHEADERTYPE *pBuffHeader, |
| CameraFrame::FrameType typeOfFrame) |
| { |
| status_t ret = NO_ERROR; |
| int currentBufferIdx, nextBufferIdx; |
| OMXCameraPortParameters * imgCaptureData = NULL; |
| |
| LOG_FUNCTION_NAME; |
| |
| imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| |
| if ( OMX_StateExecuting != mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is not in executing state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CameraBuffer *buffer = (CameraBuffer *)pBuffHeader->pAppPrivate; |
| currentBufferIdx = buffer->index; |
| |
| if ( currentBufferIdx >= imgCaptureData->mNumBufs) |
| { |
| CAMHAL_LOGEB("Invalid bracketing buffer index 0x%x", currentBufferIdx); |
| ret = -EINVAL; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| mBracketingBuffersQueued[currentBufferIdx] = false; |
| mBracketingBuffersQueuedCount--; |
| |
| if ( 0 >= mBracketingBuffersQueuedCount ) |
| { |
| nextBufferIdx = ( currentBufferIdx + 1 ) % imgCaptureData->mNumBufs; |
| mBracketingBuffersQueued[nextBufferIdx] = true; |
| mBracketingBuffersQueuedCount++; |
| mLastBracetingBufferIdx = nextBufferIdx; |
| setFrameRefCount((CameraBuffer *)imgCaptureData->mBufferHeader[nextBufferIdx]->pAppPrivate, typeOfFrame, 1); |
| returnFrame((CameraBuffer *)imgCaptureData->mBufferHeader[nextBufferIdx]->pAppPrivate, typeOfFrame); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::sendBracketFrames(size_t &framesSent) |
| { |
| status_t ret = NO_ERROR; |
| int currentBufferIdx; |
| OMXCameraPortParameters * imgCaptureData = NULL; |
| |
| LOG_FUNCTION_NAME; |
| |
| imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| framesSent = 0; |
| |
| if ( OMX_StateExecuting != mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is not in executing state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| |
| currentBufferIdx = mLastBracetingBufferIdx; |
| do |
| { |
| currentBufferIdx++; |
| currentBufferIdx %= imgCaptureData->mNumBufs; |
| if (!mBracketingBuffersQueued[currentBufferIdx] ) |
| { |
| CameraFrame cameraFrame; |
| sendCallBacks(cameraFrame, |
| imgCaptureData->mBufferHeader[currentBufferIdx], |
| imgCaptureData->mImageType, |
| imgCaptureData); |
| framesSent++; |
| } |
| } while ( currentBufferIdx != mLastBracetingBufferIdx ); |
| |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::startBracketing(int range) |
| { |
| status_t ret = NO_ERROR; |
| OMXCameraPortParameters * imgCaptureData = NULL; |
| |
| LOG_FUNCTION_NAME; |
| |
| imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| |
| if ( OMX_StateExecuting != mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is not in executing state"); |
| ret = -EINVAL; |
| } |
| |
| { |
| android::AutoMutex lock(mBracketingLock); |
| |
| if ( mBracketingEnabled ) |
| { |
| return ret; |
| } |
| } |
| |
| if ( 0 == imgCaptureData->mNumBufs ) |
| { |
| CAMHAL_LOGEB("Image capture buffers set to %d", imgCaptureData->mNumBufs); |
| ret = -EINVAL; |
| } |
| |
| if ( mPending3Asettings ) |
| apply3Asettings(mParameters3A); |
| |
| if ( NO_ERROR == ret ) |
| { |
| android::AutoMutex lock(mBracketingLock); |
| |
| mBracketingRange = range; |
| mBracketingBuffersQueued = new bool[imgCaptureData->mNumBufs]; |
| if ( NULL == mBracketingBuffersQueued ) |
| { |
| CAMHAL_LOGEA("Unable to allocate bracketing management structures"); |
| ret = -1; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| mBracketingBuffersQueuedCount = imgCaptureData->mNumBufs; |
| mBurstFramesAccum = imgCaptureData->mNumBufs; |
| mLastBracetingBufferIdx = mBracketingBuffersQueuedCount - 1; |
| |
| for ( int i = 0 ; i < imgCaptureData->mNumBufs ; i++ ) |
| { |
| mBracketingBuffersQueued[i] = true; |
| } |
| |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CachedCaptureParameters* cap_params = cacheCaptureParameters(); |
| ret = startImageCapture(true, cap_params); |
| delete cap_params; |
| { |
| android::AutoMutex lock(mBracketingLock); |
| |
| if ( NO_ERROR == ret ) |
| { |
| mBracketingEnabled = true; |
| } |
| else |
| { |
| mBracketingEnabled = false; |
| } |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::stopBracketing() |
| { |
| status_t ret = NO_ERROR; |
| |
| LOG_FUNCTION_NAME; |
| |
| ret = stopImageCapture(); |
| |
| android::AutoMutex lock(mBracketingLock); |
| |
| if ( NULL != mBracketingBuffersQueued ) |
| { |
| delete [] mBracketingBuffersQueued; |
| } |
| |
| mBracketingBuffersQueued = NULL; |
| mBracketingEnabled = false; |
| mBracketingBuffersQueuedCount = 0; |
| mLastBracetingBufferIdx = 0; |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::startImageCapture(bool bracketing, CachedCaptureParameters* capParams) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMXCameraPortParameters * capData = NULL; |
| OMX_CONFIG_BOOLEANTYPE bOMX; |
| size_t bracketingSent = 0; |
| |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex lock(mImageCaptureLock); |
| |
| if(!mCaptureConfigured) |
| { |
| ///Image capture was cancelled before we could start |
| return NO_ERROR; |
| } |
| |
| if ( 0 != mStartCaptureSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mStartCaptureSem semaphore count %d", mStartCaptureSem.Count()); |
| return NO_INIT; |
| } |
| |
| if ( !bracketing ) { |
| if ((getNextState() & (CAPTURE_ACTIVE|BRACKETING_ACTIVE)) == 0) { |
| CAMHAL_LOGDA("trying starting capture when already canceled"); |
| return NO_ERROR; |
| } |
| } |
| |
| if (!capParams) { |
| CAMHAL_LOGE("Invalid cached parameters sent!"); |
| return BAD_VALUE; |
| } |
| |
| // Camera framework doesn't expect face callbacks once capture is triggered |
| pauseFaceDetection(true); |
| |
| //During bracketing image capture is already active |
| { |
| android::AutoMutex lock(mBracketingLock); |
| if ( mBracketingEnabled ) |
| { |
| //Stop bracketing, activate normal burst for the remaining images |
| mBracketingEnabled = false; |
| ret = sendBracketFrames(bracketingSent); |
| |
| // Check if we accumulated enough buffers |
| if ( bracketingSent < ( mBracketingRange - 1 ) ) |
| { |
| mCapturedFrames = mBracketingRange + ( ( mBracketingRange - 1 ) - bracketingSent ); |
| } |
| else |
| { |
| mCapturedFrames = mBracketingRange; |
| } |
| mBurstFramesQueued = 0; |
| mBurstFramesAccum = mCapturedFrames; |
| |
| if(ret != NO_ERROR) |
| goto EXIT; |
| else |
| return ret; |
| } |
| } |
| |
| if ( NO_ERROR == ret ) { |
| if (capParams->mPendingCaptureSettings & SetRotation) { |
| mPendingCaptureSettings &= ~SetRotation; |
| ret = setPictureRotation(mPictureRotation); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("Error configuring image rotation %x", ret); |
| } |
| } |
| |
| if (capParams->mPendingCaptureSettings & SetBurstExpBracket) { |
| mPendingCaptureSettings &= ~SetBurstExpBracket; |
| if ( mBracketingSet ) { |
| ret = doExposureBracketing(capParams->mExposureBracketingValues, |
| capParams->mExposureGainBracketingValues, |
| capParams->mExposureGainBracketingModes, |
| 0, |
| 0, |
| capParams->mFlushShotConfigQueue, |
| capParams->mExposureBracketMode); |
| } else { |
| ret = doExposureBracketing(capParams->mExposureBracketingValues, |
| capParams->mExposureGainBracketingValues, |
| capParams->mExposureGainBracketingModes, |
| capParams->mExposureBracketingValidEntries, |
| capParams->mBurstFrames, |
| capParams->mFlushShotConfigQueue, |
| capParams->mExposureBracketMode); |
| } |
| |
| if ( ret != NO_ERROR ) { |
| CAMHAL_LOGEB("setExposureBracketing() failed %d", ret); |
| goto EXIT; |
| } |
| } |
| } |
| |
| #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS |
| CameraHal::PPM("startImageCapture bracketing configs done: ", &mStartCapture); |
| #endif |
| |
| capData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| |
| //OMX shutter callback events are only available in hq mode |
| if ( (HIGH_QUALITY == mCapMode) || (HIGH_QUALITY_ZSL== mCapMode)) { |
| if ( NO_ERROR == ret ) |
| { |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| (OMX_EVENTTYPE) OMX_EventIndexSettingChanged, |
| OMX_ALL, |
| OMX_TI_IndexConfigShutterCallback, |
| mStartCaptureSem); |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| ret = setShutterCallback(true); |
| } |
| |
| } |
| |
| if (mPending3Asettings) { |
| apply3Asettings(mParameters3A); |
| } |
| |
| if (ret == NO_ERROR) { |
| int index = 0; |
| int queued = 0; |
| android::AutoMutex lock(mBurstLock); |
| |
| if (capParams->mFlushShotConfigQueue) { |
| // reset shot queue |
| mCapturedFrames = mBurstFrames; |
| mBurstFramesAccum = mBurstFrames; |
| mBurstFramesQueued = 0; |
| for ( int index = 0 ; index < capData->mNumBufs ; index++ ) { |
| if (OMXCameraPortParameters::FILL == capData->mStatus[index]) { |
| mBurstFramesQueued++; |
| } |
| } |
| } else { |
| mCapturedFrames += mBurstFrames; |
| mBurstFramesAccum += mBurstFrames; |
| } |
| CAMHAL_LOGD("mBurstFramesQueued = %d mBurstFramesAccum = %d index = %d " |
| "capData->mNumBufs = %d queued = %d capData->mMaxQueueable = %d", |
| mBurstFramesQueued,mBurstFramesAccum,index, |
| capData->mNumBufs,queued,capData->mMaxQueueable); |
| CAMHAL_LOGD("%d", (mBurstFramesQueued < mBurstFramesAccum) |
| && (index < capData->mNumBufs) |
| && (queued < capData->mMaxQueueable)); |
| while ((mBurstFramesQueued < mBurstFramesAccum) && |
| (index < capData->mNumBufs) && |
| (queued < capData->mMaxQueueable)) { |
| if (capData->mStatus[index] == OMXCameraPortParameters::IDLE) { |
| CAMHAL_LOGDB("Queuing buffer on Capture port - %p", |
| capData->mBufferHeader[index]->pBuffer); |
| capData->mStatus[index] = OMXCameraPortParameters::FILL; |
| eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, |
| (OMX_BUFFERHEADERTYPE*)capData->mBufferHeader[index]); |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| mBurstFramesQueued++; |
| queued++; |
| } else if (OMXCameraPortParameters::FILL == capData->mStatus[index]) { |
| CAMHAL_LOGE("Not queueing index = %d", index); |
| queued++; |
| } |
| index++; |
| } |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| if (mRawCapture) { |
| capData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex]; |
| |
| ///Queue all the buffers on capture port |
| for ( int index = 0 ; index < capData->mNumBufs ; index++ ) { |
| CAMHAL_LOGDB("Queuing buffer on Video port (for RAW capture) - 0x%x", ( unsigned int ) capData->mBufferHeader[index]->pBuffer); |
| capData->mStatus[index] = OMXCameraPortParameters::FILL; |
| eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, |
| (OMX_BUFFERHEADERTYPE*)capData->mBufferHeader[index]); |
| |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| } |
| #endif |
| |
| mWaitingForSnapshot = true; |
| mCaptureSignalled = false; |
| |
| // Capturing command is not needed when capturing in video mode |
| // Only need to queue buffers on image ports |
| if ( ( mCapMode != VIDEO_MODE ) && ( mCapMode != VIDEO_MODE_HQ ) ) { |
| OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE); |
| bOMX.bEnabled = OMX_TRUE; |
| |
| /// sending Capturing Command to the component |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCapturing, |
| &bOMX); |
| |
| CAMHAL_LOGDB("Capture set - 0x%x", eError); |
| |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| } |
| |
| #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS |
| CameraHal::PPM("startImageCapture image buffers queued and capture enabled: ", &mStartCapture); |
| #endif |
| |
| //OMX shutter callback events are only available in hq mode |
| |
| if ( (HIGH_QUALITY == mCapMode) || (HIGH_QUALITY_ZSL== mCapMode)) |
| { |
| if ( NO_ERROR == ret ) |
| { |
| ret = mStartCaptureSem.WaitTimeout(OMX_CAPTURE_TIMEOUT); |
| } |
| |
| //If something bad happened while we wait |
| if (mComponentState != OMX_StateExecuting) |
| { |
| CAMHAL_LOGEA("Invalid State after Image Capture Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| CAMHAL_LOGDA("Shutter callback received"); |
| notifyShutterSubscribers(); |
| } |
| else |
| { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| (OMX_EVENTTYPE) OMX_EventIndexSettingChanged, |
| OMX_ALL, |
| OMX_TI_IndexConfigShutterCallback, |
| NULL); |
| CAMHAL_LOGEA("Timeout expired on shutter callback"); |
| goto EXIT; |
| } |
| |
| } |
| |
| #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS |
| CameraHal::PPM("startImageCapture shutter event received: ", &mStartCapture); |
| #endif |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| mWaitingForSnapshot = false; |
| mCaptureSignalled = false; |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::stopImageCapture() |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_BOOLEANTYPE bOMX; |
| OMXCameraPortParameters *imgCaptureData = NULL; |
| |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex lock(mImageCaptureLock); |
| |
| if (!mCaptureConfigured) { |
| //Capture is not ongoing, return from here |
| return NO_ERROR; |
| } |
| |
| if ( 0 != mStopCaptureSem.Count() ) { |
| CAMHAL_LOGEB("Error mStopCaptureSem semaphore count %d", mStopCaptureSem.Count()); |
| goto EXIT; |
| } |
| |
| // TODO(XXX): Reprocessing is currently piggy-backing capture commands |
| if (mAdapterState == REPROCESS_STATE) { |
| ret = stopReprocess(); |
| } |
| |
| //Disable the callback first |
| mWaitingForSnapshot = false; |
| |
| // OMX shutter callback events are only available in hq mode |
| if ((HIGH_QUALITY == mCapMode) || (HIGH_QUALITY_ZSL== mCapMode)) { |
| //Disable the callback first |
| ret = setShutterCallback(false); |
| |
| // if anybody is waiting on the shutter callback |
| // signal them and then recreate the semaphore |
| if ( 0 != mStartCaptureSem.Count() ) { |
| |
| for (int i = mStartCaptureSem.Count(); i < 0; i++) { |
| ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, |
| (OMX_EVENTTYPE) OMX_EventIndexSettingChanged, |
| OMX_ALL, |
| OMX_TI_IndexConfigShutterCallback, |
| NULL ); |
| } |
| mStartCaptureSem.Create(0); |
| } |
| } else if (CP_CAM == mCapMode) { |
| // Reset shot config queue |
| OMX_TI_CONFIG_ENQUEUESHOTCONFIGS resetShotConfigs; |
| OMX_INIT_STRUCT_PTR(&resetShotConfigs, OMX_TI_CONFIG_ENQUEUESHOTCONFIGS); |
| |
| resetShotConfigs.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| resetShotConfigs.bFlushQueue = OMX_TRUE; |
| resetShotConfigs.nNumConfigs = 0; |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigEnqueueShotConfigs, |
| &resetShotConfigs); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while reset shot config 0x%x", eError); |
| goto EXIT; |
| } else { |
| CAMHAL_LOGDA("Shot config reset successfully"); |
| } |
| } |
| |
| //Wait here for the capture to be done, in worst case timeout and proceed with cleanup |
| mCaptureSem.WaitTimeout(OMX_CAPTURE_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State Image Capture Stop Exitting!!!"); |
| goto EXIT; |
| } |
| |
| // Disable image capture |
| // Capturing command is not needed when capturing in video mode |
| if ( ( mCapMode != VIDEO_MODE ) && ( mCapMode != VIDEO_MODE_HQ ) ) { |
| OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE); |
| bOMX.bEnabled = OMX_FALSE; |
| imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCapturing, |
| &bOMX); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGDB("Error during SetConfig- 0x%x", eError); |
| ret = -1; |
| goto EXIT; |
| } |
| } |
| |
| CAMHAL_LOGDB("Capture set - 0x%x", eError); |
| |
| mCaptureSignalled = true; //set this to true if we exited because of timeout |
| |
| { |
| android::AutoMutex lock(mFrameCountMutex); |
| mFrameCount = 0; |
| mFirstFrameCondition.broadcast(); |
| } |
| |
| // Stop is always signalled externally in CPCAM mode |
| // We need to make sure we really stop |
| if ((mCapMode == CP_CAM)) { |
| disableReprocess(); |
| disableImagePort(); |
| if ( NULL != mReleaseImageBuffersCallback ) { |
| mReleaseImageBuffersCallback(mReleaseData); |
| } |
| } |
| |
| // Moving code for below commit here as an optimization for continuous capture, |
| // so focus settings don't have to reapplied after each capture |
| // c78fa2a CameraHAL: Always reset focus mode after capture |
| // Workaround when doing many consecutive shots, CAF wasn't getting restarted. |
| mPending3Asettings |= SetFocus; |
| |
| mCapturedFrames = 0; |
| mBurstFramesAccum = 0; |
| mBurstFramesQueued = 0; |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| //Release image buffers |
| if ( NULL != mReleaseImageBuffersCallback ) { |
| mReleaseImageBuffersCallback(mReleaseData); |
| } |
| |
| { |
| android::AutoMutex lock(mFrameCountMutex); |
| mFrameCount = 0; |
| mFirstFrameCondition.broadcast(); |
| } |
| |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::disableImagePort(){ |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMXCameraPortParameters *imgCaptureData = NULL; |
| OMXCameraPortParameters *imgRawCaptureData = NULL; |
| |
| if (!mCaptureConfigured) { |
| return NO_ERROR; |
| } |
| |
| mCaptureConfigured = false; |
| imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| imgRawCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex]; // for RAW capture |
| |
| ///Register for Image port Disable event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mImagePortIndex, |
| mStopCaptureSem); |
| ///Disable Capture Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mImagePortIndex, |
| NULL); |
| |
| ///Free all the buffers on capture port |
| if (imgCaptureData) { |
| CAMHAL_LOGDB("Freeing buffer on Capture port - %d", imgCaptureData->mNumBufs); |
| for ( int index = 0 ; index < imgCaptureData->mNumBufs ; index++) { |
| CAMHAL_LOGDB("Freeing buffer on Capture port - 0x%x", |
| ( unsigned int ) imgCaptureData->mBufferHeader[index]->pBuffer); |
| eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp, |
| mCameraAdapterParameters.mImagePortIndex, |
| (OMX_BUFFERHEADERTYPE*)imgCaptureData->mBufferHeader[index]); |
| |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| } |
| CAMHAL_LOGDA("Waiting for port disable"); |
| //Wait for the image port enable event |
| ret = mStopCaptureSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| //If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) |
| { |
| CAMHAL_LOGEA("Invalid State after Disable Image Port Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if ( NO_ERROR == ret ) { |
| CAMHAL_LOGDA("Port disabled"); |
| } else { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mImagePortIndex, |
| NULL); |
| CAMHAL_LOGDA("Timeout expired on port disable"); |
| goto EXIT; |
| } |
| |
| deinitInternalBuffers(mCameraAdapterParameters.mImagePortIndex); |
| |
| // since port settings are not persistent after port is disabled... |
| mPendingCaptureSettings |= SetFormat; |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| |
| if (mRawCapture) { |
| ///Register for Video port Disable event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| mStopCaptureSem); |
| ///Disable RawCapture Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| NULL); |
| |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| |
| ///Free all the buffers on RawCapture port |
| if (imgRawCaptureData) { |
| CAMHAL_LOGDB("Freeing buffer on Capture port - %d", imgRawCaptureData->mNumBufs); |
| for ( int index = 0 ; index < imgRawCaptureData->mNumBufs ; index++) { |
| CAMHAL_LOGDB("Freeing buffer on Capture port - 0x%x", ( unsigned int ) imgRawCaptureData->mBufferHeader[index]->pBuffer); |
| eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp, |
| mCameraAdapterParameters.mVideoPortIndex, |
| (OMX_BUFFERHEADERTYPE*)imgRawCaptureData->mBufferHeader[index]); |
| |
| GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); |
| } |
| } |
| CAMHAL_LOGDA("Waiting for Video port disable"); |
| //Wait for the image port enable event |
| mStopCaptureSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| CAMHAL_LOGDA("Video Port disabled"); |
| } |
| #endif |
| |
| EXIT: |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| } |
| |
| status_t OMXCameraAdapter::initInternalBuffers(OMX_U32 portIndex) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| int index = 0; |
| OMX_TI_PARAM_USEBUFFERDESCRIPTOR bufferdesc; |
| |
| /* Indicate to Ducati that we're planning to use dynamically-mapped buffers */ |
| OMX_INIT_STRUCT_PTR (&bufferdesc, OMX_TI_PARAM_USEBUFFERDESCRIPTOR); |
| bufferdesc.nPortIndex = portIndex; |
| bufferdesc.bEnabled = OMX_FALSE; |
| bufferdesc.eBufferType = OMX_TI_BufferTypePhysicalPageList; |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexUseBufferDescriptor, |
| &bufferdesc); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SetParameter - %x", eError); |
| return -EINVAL; |
| } |
| |
| CAMHAL_LOGDA("Initializing internal buffers"); |
| do { |
| OMX_TI_PARAM_COMPONENTBUFALLOCTYPE bufferalloc; |
| OMX_TI_PARAM_COMPONENTBUFALLOCTYPE bufferallocset; |
| OMX_INIT_STRUCT_PTR (&bufferalloc, OMX_TI_PARAM_COMPONENTBUFALLOCTYPE); |
| bufferalloc.nPortIndex = portIndex; |
| bufferalloc.nIndex = index; |
| |
| eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexParamComponentBufferAllocation, |
| &bufferalloc); |
| if (eError == OMX_ErrorNoMore) { |
| return NO_ERROR; |
| } |
| if (eError != OMX_ErrorNone) { |
| CAMHAL_LOGE("GetParameter failed error = 0x%x", eError); |
| break; |
| } |
| |
| CAMHAL_LOGDB("Requesting buftype %d of size %dx%d", |
| (int)bufferalloc.eBufType, (int)bufferalloc.nAllocWidth, |
| (int)bufferalloc.nAllocLines); |
| |
| bufferalloc.eBufType = OMX_TI_BufferTypeHardwareReserved1D; |
| |
| OMX_INIT_STRUCT_PTR (&bufferallocset, OMX_TI_PARAM_COMPONENTBUFALLOCTYPE); |
| bufferallocset.nPortIndex = portIndex; |
| bufferallocset.nIndex = index; |
| bufferallocset.eBufType = OMX_TI_BufferTypeHardwareReserved1D; |
| bufferallocset.nAllocWidth = bufferalloc.nAllocWidth; |
| bufferallocset.nAllocLines = bufferalloc.nAllocLines; |
| |
| eError = OMX_SetParameter (mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexParamComponentBufferAllocation, |
| &bufferallocset); |
| if (eError != OMX_ErrorNone) { |
| CAMHAL_LOGE("SetParameter failed, error=%08x", eError); |
| if (eError == OMX_ErrorNoMore) return NO_ERROR; |
| break; |
| } |
| |
| index++; |
| |
| /* 1 is an arbitrary limit */ |
| } while (index < 1); |
| |
| CAMHAL_LOGV("Ducati requested too many (>1) internal buffers"); |
| |
| return -EINVAL; |
| } |
| |
| status_t OMXCameraAdapter::deinitInternalBuffers(OMX_U32 portIndex) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_PARAM_USEBUFFERDESCRIPTOR bufferdesc; |
| |
| OMX_INIT_STRUCT_PTR (&bufferdesc, OMX_TI_PARAM_USEBUFFERDESCRIPTOR); |
| bufferdesc.nPortIndex = portIndex; |
| bufferdesc.bEnabled = OMX_FALSE; |
| bufferdesc.eBufferType = OMX_TI_BufferTypeDefault; |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexUseBufferDescriptor, |
| &bufferdesc); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SetParameter - %x", eError); |
| return -EINVAL; |
| } |
| |
| OMX_TI_PARAM_COMPONENTBUFALLOCTYPE bufferalloc; |
| OMX_INIT_STRUCT_PTR (&bufferalloc, OMX_TI_PARAM_COMPONENTBUFALLOCTYPE); |
| bufferalloc.nPortIndex = portIndex; |
| bufferalloc.eBufType = OMX_TI_BufferTypeDefault; |
| bufferalloc.nAllocWidth = 1; |
| bufferalloc.nAllocLines = 1; |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexParamComponentBufferAllocation, |
| &bufferalloc); |
| if (eError!=OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_SetParameter - %x", eError); |
| return -EINVAL; |
| } |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::UseBuffersCapture(CameraBuffer * bufArr, int num) |
| { |
| LOG_FUNCTION_NAME; |
| |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMXCameraPortParameters * imgCaptureData = NULL; |
| OMXCameraPortParameters cap; |
| |
| imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; |
| |
| if ( 0 != mUseCaptureSem.Count() ) |
| { |
| CAMHAL_LOGEB("Error mUseCaptureSem semaphore count %d", mUseCaptureSem.Count()); |
| return BAD_VALUE; |
| } |
| |
| CAMHAL_ASSERT(num > 0); |
| |
| // if some setting that requires a SetParameter (including |
| // changing buffer types) then we need to disable the port |
| // before being allowed to apply the settings |
| if ((mPendingCaptureSettings & ECaptureParamSettings) || |
| bufArr[0].type != imgCaptureData->mBufferType || |
| imgCaptureData->mNumBufs != num) { |
| if (mCaptureConfigured) { |
| disableImagePort(); |
| if ( NULL != mReleaseImageBuffersCallback ) { |
| mReleaseImageBuffersCallback(mReleaseData); |
| } |
| } |
| |
| imgCaptureData->mBufferType = bufArr[0].type; |
| imgCaptureData->mNumBufs = num; |
| |
| CAMHAL_LOGDB("Params Width = %d", (int)imgCaptureData->mWidth); |
| CAMHAL_LOGDB("Params Height = %d", (int)imgCaptureData->mHeight); |
| |
| if (mPendingCaptureSettings & SetFormat) { |
| mPendingCaptureSettings &= ~SetFormat; |
| ret = setFormat(OMX_CAMERA_PORT_IMAGE_OUT_IMAGE, *imgCaptureData); |
| if ( ret != NO_ERROR ) { |
| CAMHAL_LOGEB("setFormat() failed %d", ret); |
| LOG_FUNCTION_NAME_EXIT; |
| return ret; |
| } |
| } |
| |
| if (mPendingCaptureSettings & SetThumb) { |
| mPendingCaptureSettings &= ~SetThumb; |
| ret = setThumbnailParams(mThumbWidth, mThumbHeight, mThumbQuality); |
| if ( NO_ERROR != ret) { |
| CAMHAL_LOGEB("Error configuring thumbnail size %x", ret); |
| return ret; |
| } |
| } |
| |
| if (mPendingCaptureSettings & SetQuality) { |
| mPendingCaptureSettings &= ~SetQuality; |
| ret = setImageQuality(mPictureQuality); |
| if ( NO_ERROR != ret) { |
| CAMHAL_LOGEB("Error configuring image quality %x", ret); |
| goto EXIT; |
| } |
| } |
| |
| // Configure DOMX to use either gralloc handles or vptrs |
| { |
| OMX_TI_PARAMUSENATIVEBUFFER domxUseGrallocHandles; |
| OMX_INIT_STRUCT_PTR (&domxUseGrallocHandles, OMX_TI_PARAMUSENATIVEBUFFER); |
| |
| domxUseGrallocHandles.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| if (bufArr[0].type == CAMERA_BUFFER_ANW) { |
| CAMHAL_LOGD ("Using ANW Buffers"); |
| initInternalBuffers(mCameraAdapterParameters.mImagePortIndex); |
| domxUseGrallocHandles.bEnable = OMX_TRUE; |
| } else { |
| CAMHAL_LOGD ("Using ION Buffers"); |
| domxUseGrallocHandles.bEnable = OMX_FALSE; |
| } |
| |
| 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); |
| } |
| |
| #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS |
| |
| CameraHal::PPM("Takepicture image port configuration: ", &bufArr->ppmStamp); |
| |
| #endif |
| |
| // Register for Image port ENABLE event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mImagePortIndex, |
| mUseCaptureSem); |
| |
| // Enable Capture Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mImagePortIndex, |
| NULL); |
| |
| CAMHAL_LOGDB("OMX_UseBuffer = 0x%x", eError); |
| GOTO_EXIT_IF(( eError != OMX_ErrorNone ), eError); |
| |
| for (int index = 0 ; index < imgCaptureData->mNumBufs ; index++) { |
| OMX_BUFFERHEADERTYPE *pBufferHdr; |
| CAMHAL_LOGDB("OMX_UseBuffer Capture address: 0x%x, size = %d", |
| (unsigned int)bufArr[index].opaque, |
| (int)imgCaptureData->mBufSize); |
| |
| eError = OMX_UseBuffer(mCameraAdapterParameters.mHandleComp, |
| &pBufferHdr, |
| mCameraAdapterParameters.mImagePortIndex, |
| 0, |
| imgCaptureData->mBufSize, |
| (OMX_U8*)camera_buffer_get_omx_ptr(&bufArr[index])); |
| |
| CAMHAL_LOGDB("OMX_UseBuffer = 0x%x", eError); |
| GOTO_EXIT_IF(( eError != OMX_ErrorNone ), eError); |
| |
| pBufferHdr->pAppPrivate = (OMX_PTR) &bufArr[index]; |
| bufArr[index].index = 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; |
| imgCaptureData->mBufferHeader[index] = pBufferHdr; |
| imgCaptureData->mStatus[index] = OMXCameraPortParameters::IDLE; |
| } |
| |
| // Wait for the image port enable event |
| CAMHAL_LOGDA("Waiting for port enable"); |
| ret = mUseCaptureSem.WaitTimeout(OMX_CMD_TIMEOUT); |
| |
| // If somethiing bad happened while we wait |
| if (mComponentState == OMX_StateInvalid) { |
| CAMHAL_LOGEA("Invalid State after Enable Image Port Exitting!!!"); |
| goto EXIT; |
| } |
| |
| if (ret != NO_ERROR) { |
| ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp, |
| OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mImagePortIndex, |
| NULL); |
| CAMHAL_LOGDA("Timeout expired on port enable"); |
| goto EXIT; |
| } |
| CAMHAL_LOGDA("Port enabled"); |
| |
| #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS |
| |
| CameraHal::PPM("Takepicture image port enabled and buffers registered: ", &bufArr->ppmStamp); |
| |
| #endif |
| |
| if (mNextState != LOADED_REPROCESS_CAPTURE_STATE) { |
| // Enable WB and vector shot extra data for metadata |
| setExtraData(true, mCameraAdapterParameters.mImagePortIndex, OMX_WhiteBalance); |
| setExtraData(true, mCameraAdapterParameters.mImagePortIndex, OMX_TI_LSCTable); |
| } |
| |
| // CPCam mode only supports vector shot |
| // Regular capture is not supported |
| if ( (mCapMode == CP_CAM) && (mNextState != LOADED_REPROCESS_CAPTURE_STATE) ) { |
| initVectorShot(); |
| } |
| |
| mCaptureBuffersAvailable.clear(); |
| for (unsigned int i = 0; i < imgCaptureData->mMaxQueueable; i++ ) { |
| mCaptureBuffersAvailable.add(&mCaptureBuffers[i], 0); |
| } |
| |
| // initial ref count for undeqeueued buffers is 1 since buffer provider |
| // is still holding on to it |
| for (unsigned int i = imgCaptureData->mMaxQueueable; i < imgCaptureData->mNumBufs; i++ ) { |
| mCaptureBuffersAvailable.add(&mCaptureBuffers[i], 1); |
| } |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| ret = setupEXIF(); |
| if ( NO_ERROR != ret ) |
| { |
| CAMHAL_LOGEB("Error configuring EXIF Buffer %x", ret); |
| } |
| } |
| |
| // Choose proper single preview mode for cp capture (reproc or hs) |
| if (( NO_ERROR == ret) && (OMXCameraAdapter::CP_CAM == mCapMode)) { |
| OMX_TI_CONFIG_SINGLEPREVIEWMODETYPE singlePrevMode; |
| OMX_INIT_STRUCT_PTR (&singlePrevMode, OMX_TI_CONFIG_SINGLEPREVIEWMODETYPE); |
| if (mNextState == LOADED_CAPTURE_STATE) { |
| singlePrevMode.eMode = OMX_TI_SinglePreviewMode_ImageCaptureHighSpeed; |
| } else if (mNextState == LOADED_REPROCESS_CAPTURE_STATE) { |
| singlePrevMode.eMode = OMX_TI_SinglePreviewMode_Reprocess; |
| } else { |
| CAMHAL_LOGE("Wrong state trying to start a capture in CPCAM mode?"); |
| singlePrevMode.eMode = OMX_TI_SinglePreviewMode_ImageCaptureHighSpeed; |
| } |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigSinglePreviewMode, |
| &singlePrevMode); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring single preview mode 0x%x", eError); |
| ret = Utils::ErrorUtils::omxToAndroidError(eError); |
| } else { |
| CAMHAL_LOGDA("single preview mode configured successfully"); |
| } |
| } |
| |
| #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS |
| |
| CameraHal::PPM("Takepicture extra configs on image port done: ", &bufArr->ppmStamp); |
| |
| #endif |
| |
| mCaptureConfigured = true; |
| |
| #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING |
| if (mRawCapture) { |
| mCaptureConfigured = false; |
| } |
| #endif |
| |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| EXIT: |
| CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); |
| setExtraData(false, mCameraAdapterParameters.mImagePortIndex, OMX_WhiteBalance); |
| // TODO: WA: if domx client disables VectShotInfo metadata on the image port, this causes |
| // VectShotInfo to be disabled internally on preview port also. Remove setting in OMXCapture |
| // setExtraData(false, mCameraAdapterParameters.mImagePortIndex, OMX_TI_VectShotInfo); |
| setExtraData(false, mCameraAdapterParameters.mImagePortIndex, OMX_TI_LSCTable); |
| //Release image buffers |
| if ( NULL != mReleaseImageBuffersCallback ) { |
| mReleaseImageBuffersCallback(mReleaseData); |
| } |
| performCleanupAfterError(); |
| LOG_FUNCTION_NAME_EXIT; |
| return (ret | Utils::ErrorUtils::omxToAndroidError(eError)); |
| |
| } |
| status_t OMXCameraAdapter::UseBuffersRawCapture(CameraBuffer *bufArr, int num) |
| { |
| LOG_FUNCTION_NAME |
| status_t ret; |
| OMX_ERRORTYPE eError; |
| OMXCameraPortParameters * imgRawCaptureData = NULL; |
| Utils::Semaphore camSem; |
| OMXCameraPortParameters cap; |
| |
| imgRawCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex]; |
| |
| if (mCaptureConfigured) { |
| return NO_ERROR; |
| } |
| |
| camSem.Create(); |
| |
| // mWaitingForSnapshot is true only when we're in the process of capturing |
| if (mWaitingForSnapshot) { |
| ///Register for Video port Disable event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| (OMX_EVENTTYPE) OMX_EventCmdComplete, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| camSem); |
| |
| ///Disable Capture Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortDisable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| NULL); |
| |
| CAMHAL_LOGDA("Waiting for port disable"); |
| //Wait for the image port enable event |
| camSem.Wait(); |
| CAMHAL_LOGDA("Port disabled"); |
| } |
| |
| imgRawCaptureData->mNumBufs = num; |
| |
| CAMHAL_LOGDB("RAW Max sensor width = %d", (int)imgRawCaptureData->mWidth); |
| CAMHAL_LOGDB("RAW Max sensor height = %d", (int)imgRawCaptureData->mHeight); |
| |
| ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_VIDEO, *imgRawCaptureData); |
| |
| if (ret != NO_ERROR) { |
| CAMHAL_LOGEB("setFormat() failed %d", ret); |
| LOG_FUNCTION_NAME_EXIT |
| return ret; |
| } |
| |
| ///Register for Video port ENABLE event |
| ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, |
| (OMX_EVENTTYPE) OMX_EventCmdComplete, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| camSem); |
| |
| ///Enable Video Capture Port |
| eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, |
| OMX_CommandPortEnable, |
| mCameraAdapterParameters.mVideoPortIndex, |
| NULL); |
| |
| mCaptureBuffersLength = (int)imgRawCaptureData->mBufSize; |
| for ( int index = 0 ; index < imgRawCaptureData->mNumBufs ; index++ ) { |
| OMX_BUFFERHEADERTYPE *pBufferHdr; |
| CAMHAL_LOGDB("OMX_UseBuffer rawCapture address: 0x%x, size = %d ", |
| (unsigned int)bufArr[index].opaque, |
| (int)imgRawCaptureData->mBufSize ); |
| |
| eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp, |
| &pBufferHdr, |
| mCameraAdapterParameters.mVideoPortIndex, |
| 0, |
| mCaptureBuffersLength, |
| (OMX_U8*)camera_buffer_get_omx_ptr(&bufArr[index])); |
| if (eError != OMX_ErrorNone) { |
| CAMHAL_LOGEB("OMX_UseBuffer = 0x%x", eError); |
| } |
| |
| GOTO_EXIT_IF(( eError != OMX_ErrorNone ), eError); |
| |
| pBufferHdr->pAppPrivate = (OMX_PTR) &bufArr[index]; |
| bufArr[index].index = 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; |
| imgRawCaptureData->mBufferHeader[index] = pBufferHdr; |
| |
| } |
| |
| //Wait for the image port enable event |
| CAMHAL_LOGDA("Waiting for port enable"); |
| camSem.Wait(); |
| CAMHAL_LOGDA("Port enabled"); |
| |
| if (NO_ERROR == ret) { |
| ret = setupEXIF(); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("Error configuring EXIF Buffer %x", ret); |
| } |
| } |
| |
| mCapturedFrames = mBurstFrames; |
| mBurstFramesQueued = 0; |
| mCaptureConfigured = true; |
| |
| EXIT: |
| |
| if (eError != OMX_ErrorNone) { |
| if ( NULL != mErrorNotifier ) |
| { |
| mErrorNotifier->errorNotify(eError); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT |
| |
| return ret; |
| } |
| |
| } // namespace Camera |
| } // namespace Ti |
