Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7e8d4590 authored by Emilian Peev's avatar Emilian Peev
Browse files

Camera: Cleanup 'Camera2Client' device dependend code 

Bug: 34392075
Test: Manual using application.
Change-Id: I365b83c9cfbfe3ddbd9d41f2aa9788490b87b5cf
parent 2a53da43

services/camera/libcameraservice/api1/client2/FrameProcessor.cpp

+4 −25
Original line number Diff line number Diff line
@@ -41,11 +41,7 @@ FrameProcessor::FrameProcessor(wp<CameraDeviceBase> device, 
    {

        SharedParameters::Lock l(client->getParameters());



        if (client->getCameraDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_2) {

        mUsePartialResult = (mNumPartialResults > 1);

        } else {

            mUsePartialResult = l.mParameters.quirks.partialResults;

        }



        // Initialize starting 3A state

        m3aState.afTriggerId = l.mParameters.afTriggerCounter;
@@ -76,16 +72,7 @@ bool FrameProcessor::processSingleFrame(CaptureResult &frame, 


    bool isPartialResult = false;

    if (mUsePartialResult) {

        if (client->getCameraDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_2) {

        isPartialResult = frame.mResultExtras.partialResultCount < mNumPartialResults;

        } else {

            camera_metadata_entry_t entry;

            entry = frame.mMetadata.find(ANDROID_QUIRKS_PARTIAL_RESULT);

            if (entry.count > 0 &&

                    entry.data.u8[0] == ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL) {

                isPartialResult = true;

            }

        }

    }



    if (!isPartialResult && processFaceDetect(frame.mMetadata, client) != OK) {
@@ -291,16 +278,8 @@ status_t FrameProcessor::process3aState(const CaptureResult &frame, 
    gotAllStates &= updatePendingState<uint8_t>(metadata, ANDROID_CONTROL_AWB_STATE,

            &pendingState.awbState, frameNumber, cameraId);



    if (client->getCameraDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_2) {

    pendingState.afTriggerId = frame.mResultExtras.afTriggerId;

    pendingState.aeTriggerId = frame.mResultExtras.precaptureTriggerId;

    } else {

        gotAllStates &= updatePendingState<int32_t>(metadata,

                ANDROID_CONTROL_AF_TRIGGER_ID, &pendingState.afTriggerId, frameNumber, cameraId);



        gotAllStates &= updatePendingState<int32_t>(metadata,

            ANDROID_CONTROL_AE_PRECAPTURE_ID, &pendingState.aeTriggerId, frameNumber, cameraId);

    }



    if (!gotAllStates) {

        // If not all states are received, put the pending state to mPending3AStates.

services/camera/libcameraservice/api1/client2/Parameters.cpp

+22 −95
Original line number Diff line number Diff line
@@ -2854,7 +2854,6 @@ status_t Parameters::getFilteredSizes(Size limit, Vector<Size> *sizes) { 
    }

    sizes->clear();



    if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {

    Vector<StreamConfiguration> scs = getStreamConfigurations();

    for (size_t i=0; i < scs.size(); i++) {

        const StreamConfiguration &sc = scs[i];
@@ -2865,23 +2864,6 @@ status_t Parameters::getFilteredSizes(Size limit, Vector<Size> *sizes) { 
            sizes->push(sz);

        }

    }

    } else {

        const size_t SIZE_COUNT = sizeof(Size) / sizeof(int);

        camera_metadata_ro_entry_t availableProcessedSizes =

            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, SIZE_COUNT);

        if (availableProcessedSizes.count < SIZE_COUNT) return BAD_VALUE;



        Size filteredSize;

        for (size_t i = 0; i < availableProcessedSizes.count; i += SIZE_COUNT) {

            filteredSize.width = availableProcessedSizes.data.i32[i];

            filteredSize.height = availableProcessedSizes.data.i32[i+1];

                // Need skip the preview sizes that are too large.

                if (filteredSize.width <= limit.width &&

                        filteredSize.height <= limit.height) {

                    sizes->push(filteredSize);

                }

        }

    }



    if (sizes->isEmpty()) {

        ALOGE("generated preview size list is empty!!");
@@ -2934,10 +2916,6 @@ Vector<Parameters::StreamConfiguration> Parameters::getStreamConfigurations() { 
    const int STREAM_HEIGHT_OFFSET = 2;

    const int STREAM_IS_INPUT_OFFSET = 3;

    Vector<StreamConfiguration> scs;

    if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_2) {

        ALOGE("StreamConfiguration is only valid after device HAL 3.2!");

        return scs;

    }



    camera_metadata_ro_entry_t availableStreamConfigs =

                staticInfo(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
@@ -2953,37 +2931,10 @@ Vector<Parameters::StreamConfiguration> Parameters::getStreamConfigurations() { 
}



int64_t Parameters::getJpegStreamMinFrameDurationNs(Parameters::Size size) {

    if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {

    return getMinFrameDurationNs(size, HAL_PIXEL_FORMAT_BLOB);

    } else {

        Vector<Size> availableJpegSizes = getAvailableJpegSizes();

        size_t streamIdx = availableJpegSizes.size();

        for (size_t i = 0; i < availableJpegSizes.size(); i++) {

            if (availableJpegSizes[i].width == size.width &&

                    availableJpegSizes[i].height == size.height) {

                streamIdx = i;

                break;

            }

        }

        if (streamIdx != availableJpegSizes.size()) {

            camera_metadata_ro_entry_t jpegMinDurations =

                    staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS);

            if (streamIdx < jpegMinDurations.count) {

                return jpegMinDurations.data.i64[streamIdx];

            }

        }

    }

    ALOGE("%s: cannot find min frame duration for jpeg size %dx%d",

            __FUNCTION__, size.width, size.height);

    return -1;

}



int64_t Parameters::getMinFrameDurationNs(Parameters::Size size, int fmt) {

    if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_2) {

        ALOGE("Min frame duration for HAL 3.1 or lower is not supported");

        return -1;

    }



    const int STREAM_DURATION_SIZE = 4;

    const int STREAM_FORMAT_OFFSET = 0;

    const int STREAM_WIDTH_OFFSET = 1;
@@ -3005,11 +2956,6 @@ int64_t Parameters::getMinFrameDurationNs(Parameters::Size size, int fmt) { 
}



bool Parameters::isFpsSupported(const Vector<Size> &sizes, int format, int32_t fps) {

    // Skip the check for older HAL version, as the min duration is not supported.

    if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_2) {

        return true;

    }



    // Get min frame duration for each size and check if the given fps range can be supported.

    for (size_t i = 0 ; i < sizes.size(); i++) {

        int64_t minFrameDuration = getMinFrameDurationNs(sizes[i], format);
@@ -3030,7 +2976,6 @@ bool Parameters::isFpsSupported(const Vector<Size> &sizes, int format, int32_t f 


SortedVector<int32_t> Parameters::getAvailableOutputFormats() {

    SortedVector<int32_t> outputFormats; // Non-duplicated output formats

    if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {

    Vector<StreamConfiguration> scs = getStreamConfigurations();

    for (size_t i = 0; i < scs.size(); i++) {

        const StreamConfiguration &sc = scs[i];
@@ -3038,18 +2983,12 @@ SortedVector<int32_t> Parameters::getAvailableOutputFormats() { 
            outputFormats.add(sc.format);

        }

    }

    } else {

        camera_metadata_ro_entry_t availableFormats = staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);

        for (size_t i = 0; i < availableFormats.count; i++) {

            outputFormats.add(availableFormats.data.i32[i]);

        }

    }



    return outputFormats;

}



Vector<Parameters::Size> Parameters::getAvailableJpegSizes() {

    Vector<Parameters::Size> jpegSizes;

    if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {

    Vector<StreamConfiguration> scs = getStreamConfigurations();

    for (size_t i = 0; i < scs.size(); i++) {

        const StreamConfiguration &sc = scs[i];
@@ -3059,19 +2998,7 @@ Vector<Parameters::Size> Parameters::getAvailableJpegSizes() { 
            jpegSizes.add(sz);

        }

    }

    } else {

        const int JPEG_SIZE_ENTRY_COUNT = 2;

        const int WIDTH_OFFSET = 0;

        const int HEIGHT_OFFSET = 1;

        camera_metadata_ro_entry_t availableJpegSizes =

            staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);

        for (size_t i = 0; i < availableJpegSizes.count; i+= JPEG_SIZE_ENTRY_COUNT) {

            int width = availableJpegSizes.data.i32[i + WIDTH_OFFSET];

            int height = availableJpegSizes.data.i32[i + HEIGHT_OFFSET];

            Size sz = {width, height};

            jpegSizes.add(sz);

        }

    }



    return jpegSizes;

}

services/camera/libcameraservice/api1/client2/StreamingProcessor.cpp

+4 −9
Original line number Diff line number Diff line
@@ -114,18 +114,13 @@ status_t StreamingProcessor::updatePreviewRequest(const Parameters &params) { 
        }



        // Use CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG for ZSL streaming case.

        if (client->getCameraDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_0) {

        if (params.useZeroShutterLag() && !params.recordingHint) {

                res = device->createDefaultRequest(CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG,

                        &mPreviewRequest);

            res = device->createDefaultRequest(

                    CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG, &mPreviewRequest);

        } else {

            res = device->createDefaultRequest(CAMERA3_TEMPLATE_PREVIEW,

                    &mPreviewRequest);

        }

        } else {

            res = device->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,

                    &mPreviewRequest);

        }



        if (res != OK) {

            ALOGE("%s: Camera %d: Unable to create default preview request: "