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

Commit 81ae83bd authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'gralloc_usage_flags' into oc-mr1-dev 

* changes:
  Camera: Switch usage flags to 64-bit unsigned
  Camera: Remove dead legacy code
parents 770e0d68 050f5dcf

services/camera/libcameraservice/api2/CameraDeviceClient.cpp

+7 −8
Original line number Diff line number Diff line
@@ -570,7 +570,7 @@ binder::Status CameraDeviceClient::createDeferredSurfaceStreamLocked( 
        /*out*/

        int* newStreamId) {

    int width, height, format, surfaceType;

    int32_t consumerUsage;

    uint64_t consumerUsage;

    android_dataspace dataSpace;

    status_t err;

    binder::Status res;
@@ -766,24 +766,23 @@ binder::Status CameraDeviceClient::createSurfaceFromGbp( 
    // Query consumer usage bits to set async operation mode for

    // GLConsumer using controlledByApp parameter.

    bool useAsync = false;

    int32_t consumerUsage;

    uint64_t consumerUsage = 0;

    status_t err;

    if ((err = gbp->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS,

            &consumerUsage)) != OK) {

    if ((err = gbp->getConsumerUsage(&consumerUsage)) != OK) {

        String8 msg = String8::format("Camera %s: Failed to query Surface consumer usage: %s (%d)",

                mCameraIdStr.string(), strerror(-err), err);

        ALOGE("%s: %s", __FUNCTION__, msg.string());

        return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());

    }

    if (consumerUsage & GraphicBuffer::USAGE_HW_TEXTURE) {

        ALOGW("%s: Camera %s with consumer usage flag: 0x%x: Forcing asynchronous mode for stream",

        ALOGW("%s: Camera %s with consumer usage flag: %" PRIu64 ": Forcing asynchronous mode for stream",

                __FUNCTION__, mCameraIdStr.string(), consumerUsage);

        useAsync = true;

    }



    int32_t disallowedFlags = GraphicBuffer::USAGE_HW_VIDEO_ENCODER |

    uint64_t disallowedFlags = GraphicBuffer::USAGE_HW_VIDEO_ENCODER |

                              GRALLOC_USAGE_RENDERSCRIPT;

    int32_t allowedFlags = GraphicBuffer::USAGE_SW_READ_MASK |

    uint64_t allowedFlags = GraphicBuffer::USAGE_SW_READ_MASK |

                           GraphicBuffer::USAGE_HW_TEXTURE |

                           GraphicBuffer::USAGE_HW_COMPOSER;

    bool flexibleConsumer = (consumerUsage & disallowedFlags) == 0 &&
@@ -876,7 +875,7 @@ binder::Status CameraDeviceClient::createSurfaceFromGbp( 
        //surface class type. Use usage flag to approximate the comparison.

        if (consumerUsage != streamInfo.consumerUsage) {

            String8 msg = String8::format(

                    "Camera %s:Surface usage flag doesn't match 0x%x vs 0x%x",

                    "Camera %s:Surface usage flag doesn't match %" PRIu64 " vs %" PRIu64 "",

                    mCameraIdStr.string(), consumerUsage, streamInfo.consumerUsage);

            ALOGE("%s: %s", __FUNCTION__, msg.string());

            return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());

services/camera/libcameraservice/api2/CameraDeviceClient.h

+2 −2
Original line number Diff line number Diff line
@@ -213,13 +213,13 @@ private: 
        int height;

        int format;

        android_dataspace dataSpace;

        int32_t consumerUsage;

        uint64_t consumerUsage;

        bool finalized = false;

        OutputStreamInfo() :

                width(-1), height(-1), format(-1), dataSpace(HAL_DATASPACE_UNKNOWN),

                consumerUsage(0) {}

        OutputStreamInfo(int _width, int _height, int _format, android_dataspace _dataSpace,

                int32_t _consumerUsage) :

                uint64_t _consumerUsage) :

                    width(_width), height(_height), format(_format),

                    dataSpace(_dataSpace), consumerUsage(_consumerUsage) {}

    };

services/camera/libcameraservice/common/CameraDeviceBase.h

+2 −2
Original line number Diff line number Diff line
@@ -119,7 +119,7 @@ class CameraDeviceBase : public virtual RefBase { 
            uint32_t width, uint32_t height, int format,

            android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,

            int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,

            bool isShared = false, uint32_t consumerUsage = 0) = 0;

            bool isShared = false, uint64_t consumerUsage = 0) = 0;



    /**

     * Create an output stream of the requested size, format, rotation and
@@ -132,7 +132,7 @@ class CameraDeviceBase : public virtual RefBase { 
            bool hasDeferredConsumer, uint32_t width, uint32_t height, int format,

            android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,

            int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,

            bool isShared = false, uint32_t consumerUsage = 0) = 0;

            bool isShared = false, uint64_t consumerUsage = 0) = 0;



    /**

     * Create an input stream of width, height, and format.

services/camera/libcameraservice/device1/CameraHardwareInterface.cpp

+1 −264
Original line number Diff line number Diff line
@@ -29,11 +29,6 @@ using hardware::hidl_handle; 
CameraHardwareInterface::~CameraHardwareInterface()

{

    ALOGI("Destroying camera %s", mName.string());

    if (mDevice) {

        int rc = mDevice->common.close(&mDevice->common);

        if (rc != OK)

            ALOGE("Could not close camera %s: %d", mName.string(), rc);

    }

    if (mHidlDevice != nullptr) {

        mHidlDevice->close();

        mHidlDevice.clear();
@@ -42,12 +37,6 @@ CameraHardwareInterface::~CameraHardwareInterface() 
}



status_t CameraHardwareInterface::initialize(sp<CameraProviderManager> manager) {

    if (mDevice) {

        ALOGE("%s: camera hardware interface has been initialized to libhardware path!",

                __FUNCTION__);

        return INVALID_OPERATION;

    }



    ALOGI("Opening camera %s", mName.string());



    status_t ret = manager->openSession(mName.string(), this, &mHidlDevice);
@@ -372,7 +361,7 @@ CameraHardwareInterface::setUsage(hardware::graphics::common::V1_0::BufferUsage 
        ALOGE("%s: preview window is null", __FUNCTION__);

        return s;

    }

    mPreviewUsage = (int) usage;

    mPreviewUsage = static_cast<uint64_t> (usage);

    int rc = native_window_set_usage(a, mPreviewUsage);

    if (rc == OK) {

        cleanupCirculatingBuffers();
@@ -444,23 +433,6 @@ status_t CameraHardwareInterface::setPreviewWindow(const sp<ANativeWindow>& buf) 
        }

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->setPreviewWindow(buf.get() ? this : nullptr));

    } else if (mDevice) {

        if (mDevice->ops->set_preview_window) {

            mPreviewWindow = buf;

            if (buf != nullptr) {

                if (mPreviewScalingMode != NOT_SET) {

                    setPreviewScalingMode(mPreviewScalingMode);

                }

                if (mPreviewTransform != NOT_SET) {

                    setPreviewTransform(mPreviewTransform);

                }

            }

            mHalPreviewWindow.user = this;

            ALOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p",__FUNCTION__,

                    &mHalPreviewWindow, mHalPreviewWindow.user);

            return mDevice->ops->set_preview_window(mDevice,

                    buf.get() ? &mHalPreviewWindow.nw : 0);

        }

    }

    return INVALID_OPERATION;

}
@@ -478,15 +450,6 @@ void CameraHardwareInterface::setCallbacks(notify_callback notify_cb, 
    mCbUser = user;



    ALOGV("%s(%s)", __FUNCTION__, mName.string());



    if (mDevice && mDevice->ops->set_callbacks) {

        mDevice->ops->set_callbacks(mDevice,

                               sNotifyCb,

                               sDataCb,

                               sDataCbTimestamp,

                               sGetMemory,

                               this);

    }

}



void CameraHardwareInterface::enableMsgType(int32_t msgType)
@@ -494,8 +457,6 @@ void CameraHardwareInterface::enableMsgType(int32_t msgType) 
    ALOGV("%s(%s)", __FUNCTION__, mName.string());

    if (CC_LIKELY(mHidlDevice != nullptr)) {

        mHidlDevice->enableMsgType(msgType);

    } else if (mDevice && mDevice->ops->enable_msg_type) {

        mDevice->ops->enable_msg_type(mDevice, msgType);

    }

}
@@ -504,8 +465,6 @@ void CameraHardwareInterface::disableMsgType(int32_t msgType) 
    ALOGV("%s(%s)", __FUNCTION__, mName.string());

    if (CC_LIKELY(mHidlDevice != nullptr)) {

        mHidlDevice->disableMsgType(msgType);

    } else if (mDevice && mDevice->ops->disable_msg_type) {

        mDevice->ops->disable_msg_type(mDevice, msgType);

    }

}
@@ -514,8 +473,6 @@ int CameraHardwareInterface::msgTypeEnabled(int32_t msgType) 
    ALOGV("%s(%s)", __FUNCTION__, mName.string());

    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return mHidlDevice->msgTypeEnabled(msgType);

    } else if (mDevice && mDevice->ops->msg_type_enabled) {

        return mDevice->ops->msg_type_enabled(mDevice, msgType);

    }

    return false;

}
@@ -526,8 +483,6 @@ status_t CameraHardwareInterface::startPreview() 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->startPreview());

    } else if (mDevice && mDevice->ops->start_preview) {

        return mDevice->ops->start_preview(mDevice);

    }

    return INVALID_OPERATION;

}
@@ -537,8 +492,6 @@ void CameraHardwareInterface::stopPreview() 
    ALOGV("%s(%s)", __FUNCTION__, mName.string());

    if (CC_LIKELY(mHidlDevice != nullptr)) {

        mHidlDevice->stopPreview();

    } else if (mDevice && mDevice->ops->stop_preview) {

        mDevice->ops->stop_preview(mDevice);

    }

}
@@ -547,8 +500,6 @@ int CameraHardwareInterface::previewEnabled() 
    ALOGV("%s(%s)", __FUNCTION__, mName.string());

    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return mHidlDevice->previewEnabled();

    } else if (mDevice && mDevice->ops->preview_enabled) {

        return mDevice->ops->preview_enabled(mDevice);

    }

    return false;

}
@@ -559,8 +510,6 @@ status_t CameraHardwareInterface::storeMetaDataInBuffers(int enable) 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->storeMetaDataInBuffers(enable));

    } else if (mDevice && mDevice->ops->store_meta_data_in_buffers) {

        return mDevice->ops->store_meta_data_in_buffers(mDevice, enable);

    }

    return enable ? INVALID_OPERATION: OK;

}
@@ -571,8 +520,6 @@ status_t CameraHardwareInterface::startRecording() 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->startRecording());

    } else if (mDevice && mDevice->ops->start_recording) {

        return mDevice->ops->start_recording(mDevice);

    }

    return INVALID_OPERATION;

}
@@ -585,8 +532,6 @@ void CameraHardwareInterface::stopRecording() 
    ALOGV("%s(%s)", __FUNCTION__, mName.string());

    if (CC_LIKELY(mHidlDevice != nullptr)) {

        mHidlDevice->stopRecording();

    } else if (mDevice && mDevice->ops->stop_recording) {

        mDevice->ops->stop_recording(mDevice);

    }

}
@@ -598,8 +543,6 @@ int CameraHardwareInterface::recordingEnabled() 
    ALOGV("%s(%s)", __FUNCTION__, mName.string());

    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return mHidlDevice->recordingEnabled();

    } else if (mDevice && mDevice->ops->recording_enabled) {

        return mDevice->ops->recording_enabled(mDevice);

    }

    return false;

}
@@ -624,9 +567,6 @@ void CameraHardwareInterface::releaseRecordingFrame(const sp<IMemory>& mem) 
        } else {

            mHidlDevice->releaseRecordingFrame(heapId, bufferIndex);

        }

    } else if (mDevice && mDevice->ops->release_recording_frame) {

        void *data = ((uint8_t *)heap->base()) + offset;

        return mDevice->ops->release_recording_frame(mDevice, data);

    }

}
@@ -653,9 +593,6 @@ void CameraHardwareInterface::releaseRecordingFrameBatch(const std::vector<sp<IM 
                ALOGE("%s only supports VideoNativeHandleMetadata mode", __FUNCTION__);

                return;

            }

        } else {

            ALOGE("Non HIDL mode do not support %s", __FUNCTION__);

            return;

        }

    }
@@ -674,8 +611,6 @@ status_t CameraHardwareInterface::autoFocus() 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->autoFocus());

    } else if (mDevice && mDevice->ops->auto_focus) {

        return mDevice->ops->auto_focus(mDevice);

    }

    return INVALID_OPERATION;

}
@@ -686,8 +621,6 @@ status_t CameraHardwareInterface::cancelAutoFocus() 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->cancelAutoFocus());

    } else if (mDevice && mDevice->ops->cancel_auto_focus) {

        return mDevice->ops->cancel_auto_focus(mDevice);

    }

    return INVALID_OPERATION;

}
@@ -698,8 +631,6 @@ status_t CameraHardwareInterface::takePicture() 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->takePicture());

    } else if (mDevice && mDevice->ops->take_picture) {

        return mDevice->ops->take_picture(mDevice);

    }

    return INVALID_OPERATION;

}
@@ -710,8 +641,6 @@ status_t CameraHardwareInterface::cancelPicture() 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->cancelPicture());

    } else if (mDevice && mDevice->ops->cancel_picture) {

        return mDevice->ops->cancel_picture(mDevice);

    }

    return INVALID_OPERATION;

}
@@ -722,8 +651,6 @@ status_t CameraHardwareInterface::setParameters(const CameraParameters &params) 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->setParameters(params.flatten().string()));

    } else if (mDevice && mDevice->ops->set_parameters) {

        return mDevice->ops->set_parameters(mDevice, params.flatten().string());

    }

    return INVALID_OPERATION;

}
@@ -740,14 +667,6 @@ CameraParameters CameraHardwareInterface::getParameters() const 
                });

        String8 tmp(outParam.c_str());

        parms.unflatten(tmp);

    } else if (mDevice && mDevice->ops->get_parameters) {

        char *temp = mDevice->ops->get_parameters(mDevice);

        String8 str_parms(temp);

        if (mDevice->ops->put_parameters)

            mDevice->ops->put_parameters(mDevice, temp);

        else

            free(temp);

        parms.unflatten(str_parms);

    }

    return parms;

}
@@ -758,8 +677,6 @@ status_t CameraHardwareInterface::sendCommand(int32_t cmd, int32_t arg1, int32_t 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        return CameraProviderManager::mapToStatusT(

                mHidlDevice->sendCommand((CommandType) cmd, arg1, arg2));

    } else if (mDevice && mDevice->ops->send_command) {

        return mDevice->ops->send_command(mDevice, cmd, arg1, arg2);

    }

    return INVALID_OPERATION;

}
@@ -773,8 +690,6 @@ void CameraHardwareInterface::release() { 
    if (CC_LIKELY(mHidlDevice != nullptr)) {

        mHidlDevice->close();

        mHidlDevice.clear();

    } else if (mDevice && mDevice->ops->release) {

        mDevice->ops->release(mDevice);

    }

}
@@ -790,15 +705,10 @@ status_t CameraHardwareInterface::dump(int fd, const Vector<String16>& /*args*/) 
        Status s = mHidlDevice->dumpState(handle);

        native_handle_delete(handle);

        return CameraProviderManager::mapToStatusT(s);

    } else if (mDevice && mDevice->ops->dump) {

        return mDevice->ops->dump(mDevice, fd);

    }

    return OK; // It's fine if the HAL doesn't implement dump()

}



/**

 * Methods for legacy (non-HIDL) path follows

 */

void CameraHardwareInterface::sNotifyCb(int32_t msg_type, int32_t ext1,

                        int32_t ext2, void *user)

{
@@ -868,177 +778,4 @@ void CameraHardwareInterface::sPutMemory(camera_memory_t *data) 
    mem->decStrong(mem);

}



ANativeWindow* CameraHardwareInterface::sToAnw(void *user)

{

    CameraHardwareInterface *object =

            reinterpret_cast<CameraHardwareInterface *>(user);

    return object->mPreviewWindow.get();

}

#define anw(n) sToAnw(((struct camera_preview_window *)(n))->user)

#define hwi(n) reinterpret_cast<CameraHardwareInterface *>(\

    ((struct camera_preview_window *)(n))->user)



int CameraHardwareInterface::sDequeueBuffer(struct preview_stream_ops* w,

                            buffer_handle_t** buffer, int *stride)

{

    int rc;

    ANativeWindow *a = anw(w);

    ANativeWindowBuffer* anb;

    rc = native_window_dequeue_buffer_and_wait(a, &anb);

    if (rc == OK) {

        *buffer = &anb->handle;

        *stride = anb->stride;

    }

    return rc;

}



#ifndef container_of

#define container_of(ptr, type, member) ({                      \

    const __typeof__(((type *) 0)->member) *__mptr = (ptr);     \

    (type *) ((char *) __mptr - (char *)(&((type *)0)->member)); })

#endif



int CameraHardwareInterface::sLockBuffer(struct preview_stream_ops* w,

                  buffer_handle_t* /*buffer*/)

{

    ANativeWindow *a = anw(w);

    (void)a;

    return 0;

}



int CameraHardwareInterface::sEnqueueBuffer(struct preview_stream_ops* w,

                  buffer_handle_t* buffer)

{

    ANativeWindow *a = anw(w);

    return a->queueBuffer(a,

              container_of(buffer, ANativeWindowBuffer, handle), -1);

}



int CameraHardwareInterface::sCancelBuffer(struct preview_stream_ops* w,

                  buffer_handle_t* buffer)

{

    ANativeWindow *a = anw(w);

    return a->cancelBuffer(a,

              container_of(buffer, ANativeWindowBuffer, handle), -1);

}



int CameraHardwareInterface::sSetBufferCount(struct preview_stream_ops* w, int count)

{

    ANativeWindow *a = anw(w);



    if (a != nullptr) {

        // Workaround for b/27039775

        // Previously, setting the buffer count would reset the buffer

        // queue's flag that allows for all buffers to be dequeued on the

        // producer side, instead of just the producer's declared max count,

        // if no filled buffers have yet been queued by the producer.  This

        // reset no longer happens, but some HALs depend on this behavior,

        // so it needs to be maintained for HAL backwards compatibility.

        // Simulate the prior behavior by disconnecting/reconnecting to the

        // window and setting the values again.  This has the drawback of

        // actually causing memory reallocation, which may not have happened

        // in the past.

        CameraHardwareInterface *hw = hwi(w);

        native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA);

        native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA);

        if (hw->mPreviewScalingMode != NOT_SET) {

            native_window_set_scaling_mode(a, hw->mPreviewScalingMode);

        }

        if (hw->mPreviewTransform != NOT_SET) {

            native_window_set_buffers_transform(a, hw->mPreviewTransform);

        }

        if (hw->mPreviewWidth != NOT_SET) {

            native_window_set_buffers_dimensions(a,

                    hw->mPreviewWidth, hw->mPreviewHeight);

            native_window_set_buffers_format(a, hw->mPreviewFormat);

        }

        if (hw->mPreviewUsage != 0) {

            native_window_set_usage(a, hw->mPreviewUsage);

        }

        if (hw->mPreviewSwapInterval != NOT_SET) {

            a->setSwapInterval(a, hw->mPreviewSwapInterval);

        }

        if (hw->mPreviewCrop.left != NOT_SET) {

            native_window_set_crop(a, &(hw->mPreviewCrop));

        }

    }



    return native_window_set_buffer_count(a, count);

}



int CameraHardwareInterface::sSetBuffersGeometry(struct preview_stream_ops* w,

                  int width, int height, int format)

{

    int rc;

    ANativeWindow *a = anw(w);

    CameraHardwareInterface *hw = hwi(w);

    hw->mPreviewWidth = width;

    hw->mPreviewHeight = height;

    hw->mPreviewFormat = format;

    rc = native_window_set_buffers_dimensions(a, width, height);

    if (rc == OK) {

        rc = native_window_set_buffers_format(a, format);

    }

    return rc;

}



int CameraHardwareInterface::sSetCrop(struct preview_stream_ops *w,

                  int left, int top, int right, int bottom)

{

    ANativeWindow *a = anw(w);

    CameraHardwareInterface *hw = hwi(w);

    hw->mPreviewCrop.left = left;

    hw->mPreviewCrop.top = top;

    hw->mPreviewCrop.right = right;

    hw->mPreviewCrop.bottom = bottom;

    return native_window_set_crop(a, &(hw->mPreviewCrop));

}



int CameraHardwareInterface::sSetTimestamp(struct preview_stream_ops *w,

                           int64_t timestamp) {

    ANativeWindow *a = anw(w);

    return native_window_set_buffers_timestamp(a, timestamp);

}



int CameraHardwareInterface::sSetUsage(struct preview_stream_ops* w, int usage)

{

    ANativeWindow *a = anw(w);

    CameraHardwareInterface *hw = hwi(w);

    hw->mPreviewUsage = usage;

    return native_window_set_usage(a, usage);

}



int CameraHardwareInterface::sSetSwapInterval(struct preview_stream_ops *w, int interval)

{

    ANativeWindow *a = anw(w);

    CameraHardwareInterface *hw = hwi(w);

    hw->mPreviewSwapInterval = interval;

    return a->setSwapInterval(a, interval);

}



int CameraHardwareInterface::sGetMinUndequeuedBufferCount(

                  const struct preview_stream_ops *w,

                  int *count)

{

    ANativeWindow *a = anw(w);

    return a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, count);

}



void CameraHardwareInterface::initHalPreviewWindow()

{

    mHalPreviewWindow.nw.cancel_buffer = sCancelBuffer;

    mHalPreviewWindow.nw.lock_buffer = sLockBuffer;

    mHalPreviewWindow.nw.dequeue_buffer = sDequeueBuffer;

    mHalPreviewWindow.nw.enqueue_buffer = sEnqueueBuffer;

    mHalPreviewWindow.nw.set_buffer_count = sSetBufferCount;

    mHalPreviewWindow.nw.set_buffers_geometry = sSetBuffersGeometry;

    mHalPreviewWindow.nw.set_crop = sSetCrop;

    mHalPreviewWindow.nw.set_timestamp = sSetTimestamp;

    mHalPreviewWindow.nw.set_usage = sSetUsage;

    mHalPreviewWindow.nw.set_swap_interval = sSetSwapInterval;



    mHalPreviewWindow.nw.get_min_undequeued_buffer_count =

            sGetMinUndequeuedBufferCount;

}



}; // namespace android

services/camera/libcameraservice/device1/CameraHardwareInterface.h

+1 −45
Original line number Diff line number Diff line
@@ -90,7 +90,6 @@ class CameraHardwareInterface : 


public:

    explicit CameraHardwareInterface(const char *name):

            mDevice(nullptr),

            mHidlDevice(nullptr),

            mName(name),

            mPreviewScalingMode(NOT_SET),
@@ -299,7 +298,6 @@ public: 
    status_t dump(int fd, const Vector<String16>& /*args*/) const;



private:

    camera_device_t *mDevice;

    sp<hardware::camera::device::V1_0::ICameraDevice> mHidlDevice;

    String8 mName;
@@ -369,41 +367,6 @@ private: 


    static void sPutMemory(camera_memory_t *data);



    static ANativeWindow *sToAnw(void *user);



    static int sDequeueBuffer(struct preview_stream_ops* w,

                                buffer_handle_t** buffer, int *stride);



    static int sLockBuffer(struct preview_stream_ops* w,

                      buffer_handle_t* /*buffer*/);



    static int sEnqueueBuffer(struct preview_stream_ops* w,

                      buffer_handle_t* buffer);



    static int sCancelBuffer(struct preview_stream_ops* w,

                      buffer_handle_t* buffer);



    static int sSetBufferCount(struct preview_stream_ops* w, int count);



    static int sSetBuffersGeometry(struct preview_stream_ops* w,

                      int width, int height, int format);



    static int sSetCrop(struct preview_stream_ops *w,

                      int left, int top, int right, int bottom);



    static int sSetTimestamp(struct preview_stream_ops *w,

                               int64_t timestamp);



    static int sSetUsage(struct preview_stream_ops* w, int usage);



    static int sSetSwapInterval(struct preview_stream_ops *w, int interval);



    static int sGetMinUndequeuedBufferCount(

                      const struct preview_stream_ops *w,

                      int *count);



    void initHalPreviewWindow();



    std::pair<bool, uint64_t> getBufferId(ANativeWindowBuffer* anb);

    void cleanupCirculatingBuffers();
@@ -459,13 +422,6 @@ private: 


    sp<ANativeWindow>        mPreviewWindow;



    struct camera_preview_window {

        struct preview_stream_ops nw;

        void *user;

    };



    struct camera_preview_window mHalPreviewWindow;



    notify_callback               mNotifyCb;

    data_callback                 mDataCb;

    data_callback_timestamp       mDataCbTimestamp;
@@ -479,7 +435,7 @@ private: 
    int mPreviewWidth;

    int mPreviewHeight;

    int mPreviewFormat;

    int mPreviewUsage;

    uint64_t mPreviewUsage;

    int mPreviewSwapInterval;

    android_native_rect_t mPreviewCrop;