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

Commit b5df547b authored by Yin-Chia Yeh's avatar Yin-Chia Yeh
Browse files

Camera: HAL1 recording batching support 

Test: Angler HAL1 + batching normal recording mode
Bug: 35997432
Change-Id: If088715ccdb40163f44150c16deed62432692c07
parent 32efa2fd

camera/Camera.cpp

+45 −0
Original line number Diff line number Diff line
@@ -240,6 +240,14 @@ void Camera::releaseRecordingFrameHandle(native_handle_t* handle) 
    c->releaseRecordingFrameHandle(handle);

}



void Camera::releaseRecordingFrameHandleBatch(

        const std::vector<native_handle_t*> handles) {

    ALOGV("releaseRecordingFrameHandleBatch");

    sp <::android::hardware::ICamera> c = mCamera;

    if (c == 0) return;

    c->releaseRecordingFrameHandleBatch(handles);

}



// get preview state

bool Camera::previewEnabled()

{
@@ -418,6 +426,37 @@ void Camera::recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_han 
    }

}



void Camera::recordingFrameHandleCallbackTimestampBatch(

        const std::vector<nsecs_t>& timestamps,

        const std::vector<native_handle_t*>& handles)

{

    // If recording proxy listener is registered, forward the frame and return.

    // The other listener (mListener) is ignored because the receiver needs to

    // call releaseRecordingFrameHandle.

    sp<ICameraRecordingProxyListener> proxylistener;

    {

        Mutex::Autolock _l(mLock);

        proxylistener = mRecordingProxyListener;

    }

    if (proxylistener != NULL) {

        proxylistener->recordingFrameHandleCallbackTimestampBatch(timestamps, handles);

        return;

    }



    sp<CameraListener> listener;

    {

        Mutex::Autolock _l(mLock);

        listener = mListener;

    }



    if (listener != NULL) {

        listener->postRecordingFrameHandleTimestampBatch(timestamps, handles);

    } else {

        ALOGW("No listener was set. Drop a batch of recording frames.");

        releaseRecordingFrameHandleBatch(handles);

    }

}



sp<ICameraRecordingProxy> Camera::getRecordingProxy() {

    ALOGV("getProxy");

    return new RecordingProxy(this);
@@ -448,6 +487,12 @@ void Camera::RecordingProxy::releaseRecordingFrameHandle(native_handle_t* handle 
    mCamera->releaseRecordingFrameHandle(handle);

}



void Camera::RecordingProxy::releaseRecordingFrameHandleBatch(

        const std::vector<native_handle_t*>& handles) {

    ALOGV("RecordingProxy::releaseRecordingFrameHandleBatch");

    mCamera->releaseRecordingFrameHandleBatch(handles);

}



Camera::RecordingProxy::RecordingProxy(const sp<Camera>& camera)

{

    mCamera = camera;

camera/ICamera.cpp

+32 −0
Original line number Diff line number Diff line
@@ -55,6 +55,7 @@ enum { 
    SET_VIDEO_BUFFER_MODE,

    SET_VIDEO_BUFFER_TARGET,

    RELEASE_RECORDING_FRAME_HANDLE,

    RELEASE_RECORDING_FRAME_HANDLE_BATCH,

};



class BpCamera: public BpInterface<ICamera>
@@ -172,6 +173,24 @@ public: 
        native_handle_delete(handle);

    }



    void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {

        ALOGV("releaseRecordingFrameHandleBatch");

        Parcel data, reply;

        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());

        uint32_t n = handles.size();

        data.writeUint32(n);

        for (auto& handle : handles) {

            data.writeNativeHandle(handle);

        }

        remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);



        // Close the native handle because camera received a dup copy.

        for (auto& handle : handles) {

            native_handle_close(handle);

            native_handle_delete(handle);

        }

    }



    status_t setVideoBufferMode(int32_t videoBufferMode)

    {

        ALOGV("setVideoBufferMode: %d", videoBufferMode);
@@ -378,6 +397,19 @@ status_t BnCamera::onTransact( 
            releaseRecordingFrameHandle(data.readNativeHandle());

            return NO_ERROR;

        } break;

        case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {

            ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");

            CHECK_INTERFACE(ICamera, data, reply);

            // releaseRecordingFrameHandle will be responsble to close the native handle.

            uint32_t n = data.readUint32();

            std::vector<native_handle_t*> handles;

            handles.reserve(n);

            for (uint32_t i = 0; i < n; i++) {

                handles.push_back(data.readNativeHandle());

            }

            releaseRecordingFrameHandleBatch(handles);

            return NO_ERROR;

        } break;

        case SET_VIDEO_BUFFER_MODE: {

            ALOGV("SET_VIDEO_BUFFER_MODE");

            CHECK_INTERFACE(ICamera, data, reply);

camera/ICameraClient.cpp

+59 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ enum { 
    DATA_CALLBACK,

    DATA_CALLBACK_TIMESTAMP,

    RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,

    RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH,

};



class BpCameraClient: public BpInterface<ICameraClient>
@@ -91,6 +92,29 @@ public: 
        remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP, data, &reply,

                IBinder::FLAG_ONEWAY);

    }



    void recordingFrameHandleCallbackTimestampBatch(

            const std::vector<nsecs_t>& timestamps,

            const std::vector<native_handle_t*>& handles) {

        ALOGV("recordingFrameHandleCallbackTimestampBatch");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());

        uint32_t n = timestamps.size();

        if (n != handles.size()) {

            ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",

                    __FUNCTION__, timestamps.size(), handles.size());

            return;

        }

        data.writeUint32(n);

        for (auto ts : timestamps) {

            data.writeInt64(ts);

        }

        for (auto& handle : handles) {

            data.writeNativeHandle(handle);

        }

        remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,

                IBinder::FLAG_ONEWAY);

    }

};



IMPLEMENT_META_INTERFACE(CameraClient, "android.hardware.ICameraClient");
@@ -154,6 +178,41 @@ status_t BnCameraClient::onTransact( 
            recordingFrameHandleCallbackTimestamp(timestamp, handle);

            return NO_ERROR;

        } break;

        case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {

            ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");

            CHECK_INTERFACE(ICameraClient, data, reply);

            uint32_t n = 0;

            status_t res = data.readUint32(&n);

            if (res != OK) {

                ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);

                return BAD_VALUE;

            }

            std::vector<nsecs_t> timestamps;

            std::vector<native_handle_t*> handles;

            timestamps.reserve(n);

            handles.reserve(n);

            for (uint32_t i = 0; i < n; i++) {

                res = data.readInt64(&timestamps[i]);

                if (res != OK) {

                    ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",

                            __FUNCTION__, i, strerror(-res), res);

                    return BAD_VALUE;

                }

            }

            for (uint32_t i = 0; i < n; i++) {

                native_handle_t* handle = data.readNativeHandle();

                if (handle == nullptr) {

                    ALOGE("%s: Received a null native handle at handles[%d]",

                            __FUNCTION__, i);

                    return BAD_VALUE;

                }

                handles.push_back(handle);

            }



            // The native handle will be freed in BpCamera::releaseRecordingFrameHandleBatch.

            recordingFrameHandleCallbackTimestampBatch(timestamps, handles);

            return NO_ERROR;

        } break;

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }

camera/ICameraRecordingProxy.cpp

+44 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ enum { 
    STOP_RECORDING,

    RELEASE_RECORDING_FRAME,

    RELEASE_RECORDING_FRAME_HANDLE,

    RELEASE_RECORDING_FRAME_HANDLE_BATCH,

};
@@ -82,6 +83,24 @@ public: 
        native_handle_close(handle);

        native_handle_delete(handle);

    }



    void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {

        ALOGV("releaseRecordingFrameHandleBatch");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());

        uint32_t n = handles.size();

        data.writeUint32(n);

        for (auto& handle : handles) {

            data.writeNativeHandle(handle);

        }

        remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);



        // Close the native handle because camera received a dup copy.

        for (auto& handle : handles) {

            native_handle_close(handle);

            native_handle_delete(handle);

        }

    }

};



IMPLEMENT_META_INTERFACE(CameraRecordingProxy, "android.hardware.ICameraRecordingProxy");
@@ -121,6 +140,31 @@ status_t BnCameraRecordingProxy::onTransact( 
            releaseRecordingFrameHandle(data.readNativeHandle());

            return NO_ERROR;

        } break;

        case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {

            ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);

            uint32_t n = 0;

            status_t res = data.readUint32(&n);

            if (res != OK) {

                ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);

                return BAD_VALUE;

            }

            std::vector<native_handle_t*> handles;

            handles.reserve(n);

            for (uint32_t i = 0; i < n; i++) {

                native_handle_t* handle = data.readNativeHandle();

                if (handle == nullptr) {

                    ALOGE("%s: Received a null native handle at handles[%d]",

                            __FUNCTION__, i);

                    return BAD_VALUE;

                }

                handles.push_back(handle);

            }



            // releaseRecordingFrameHandleBatch will be responsble to close the native handle.

            releaseRecordingFrameHandleBatch(handles);

            return NO_ERROR;

        } break;

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }

camera/ICameraRecordingProxyListener.cpp

+66 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ namespace android { 
enum {

    DATA_CALLBACK_TIMESTAMP = IBinder::FIRST_CALL_TRANSACTION,

    RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,

    RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH

};



class BpCameraRecordingProxyListener: public BpInterface<ICameraRecordingProxyListener>
@@ -62,6 +63,36 @@ public: 
        native_handle_close(handle);

        native_handle_delete(handle);

    }



    void recordingFrameHandleCallbackTimestampBatch(

            const std::vector<nsecs_t>& timestamps,

            const std::vector<native_handle_t*>& handles) {

        ALOGV("recordingFrameHandleCallbackTimestampBatch");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxyListener::getInterfaceDescriptor());



        uint32_t n = timestamps.size();

        if (n != handles.size()) {

            ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",

                    __FUNCTION__, timestamps.size(), handles.size());

            return;

        }

        data.writeUint32(n);

        for (auto ts : timestamps) {

            data.writeInt64(ts);

        }

        for (auto& handle : handles) {

            data.writeNativeHandle(handle);

        }

        remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,

                IBinder::FLAG_ONEWAY);



        // The native handle is dupped in ICameraClient so we need to free it here.

        for (auto& handle : handles) {

            native_handle_close(handle);

            native_handle_delete(handle);

        }

    }

};



IMPLEMENT_META_INTERFACE(CameraRecordingProxyListener, "android.hardware.ICameraRecordingProxyListener");
@@ -101,6 +132,41 @@ status_t BnCameraRecordingProxyListener::onTransact( 
            recordingFrameHandleCallbackTimestamp(timestamp, handle);

            return NO_ERROR;

        } break;

        case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {

            ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");

            CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);

            uint32_t n = 0;

            status_t res = data.readUint32(&n);

            if (res != OK) {

                ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);

                return BAD_VALUE;

            }

            std::vector<nsecs_t> timestamps;

            std::vector<native_handle_t*> handles;

            timestamps.reserve(n);

            handles.reserve(n);

            for (uint32_t i = 0; i < n; i++) {

                res = data.readInt64(&timestamps[i]);

                if (res != OK) {

                    ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",

                            __FUNCTION__, i, strerror(-res), res);

                    return BAD_VALUE;

                }

            }

            for (uint32_t i = 0; i < n; i++) {

                native_handle_t* handle = data.readNativeHandle();

                if (handle == nullptr) {

                    ALOGE("%s: Received a null native handle at handles[%d]",

                            __FUNCTION__, i);

                    return BAD_VALUE;

                }

                handles.push_back(handle);

            }

            // The native handle will be freed in

            // BpCameraRecordingProxy::releaseRecordingFrameHandleBatch.

            recordingFrameHandleCallbackTimestampBatch(timestamps, handles);

            return NO_ERROR;

        } break;

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }