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

Commit b8ed8efe authored by Eino-Ville Talvala's avatar Eino-Ville Talvala
Browse files

Camera: Remove old recording path support 

With HALv1 now unsupported, remove recording codepaths that only it
needed
- Remove all support for metadata types besides ANWBuffer in CameraSource
- Remove now-unused Binder calls between camera service and CameraSource
- Delete code in record.cpp that was ifdef#0 anyway, and wouldn't have worked
  on Pixels for years

Test: atest android.hardware.cts.CameraTest && MediaRecorderTest && RecordingTest
Bug: 136024295
Change-Id: I87c4c32c1ebf1d0c39eaee15adc16b39c10525e8
parent a976df84

camera/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -38,7 +38,6 @@ cc_library_shared { 
        "ICamera.cpp",

        "ICameraClient.cpp",

        "ICameraRecordingProxy.cpp",

        "ICameraRecordingProxyListener.cpp",

        "camera2/CaptureRequest.cpp",

        "camera2/ConcurrentCamera.cpp",

        "camera2/OutputConfiguration.cpp",

camera/Camera.cpp

+1 −69
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ 
#include <binder/IMemory.h>



#include <Camera.h>

#include <ICameraRecordingProxyListener.h>

#include <android/hardware/ICameraService.h>

#include <android/hardware/ICamera.h>
@@ -157,10 +156,6 @@ void Camera::stopPreview() 
void Camera::stopRecording()

{

    ALOGV("stopRecording");

    {

        Mutex::Autolock _l(mLock);

        mRecordingProxyListener.clear();

    }

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

    if (c == 0) return;

    c->stopRecording();
@@ -268,12 +263,6 @@ void Camera::setListener(const sp<CameraListener>& listener) 
    mListener = listener;

}



void Camera::setRecordingProxyListener(const sp<ICameraRecordingProxyListener>& listener)

{

    Mutex::Autolock _l(mLock);

    mRecordingProxyListener = listener;

}



void Camera::setPreviewCallbackFlags(int flag)

{

    ALOGV("setPreviewCallbackFlags");
@@ -327,19 +316,6 @@ void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, 
// callback from camera service when timestamped frame is ready

void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)

{

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

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

    // call releaseRecordingFrame.

    sp<ICameraRecordingProxyListener> proxylistener;

    {

        Mutex::Autolock _l(mLock);

        proxylistener = mRecordingProxyListener;

    }

    if (proxylistener != NULL) {

        proxylistener->dataCallbackTimestamp(timestamp, msgType, dataPtr);

        return;

    }



    sp<CameraListener> listener;

    {

        Mutex::Autolock _l(mLock);
@@ -356,19 +332,6 @@ void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp< 


void Camera::recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle)

{

    // 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->recordingFrameHandleCallbackTimestamp(timestamp, handle);

        return;

    }



    sp<CameraListener> listener;

    {

        Mutex::Autolock _l(mLock);
@@ -387,19 +350,6 @@ 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);
@@ -419,10 +369,9 @@ sp<ICameraRecordingProxy> Camera::getRecordingProxy() { 
    return new RecordingProxy(this);

}



status_t Camera::RecordingProxy::startRecording(const sp<ICameraRecordingProxyListener>& listener)

status_t Camera::RecordingProxy::startRecording()

{

    ALOGV("RecordingProxy::startRecording");

    mCamera->setRecordingProxyListener(listener);

    mCamera->reconnect();

    return mCamera->startRecording();

}
@@ -433,23 +382,6 @@ void Camera::RecordingProxy::stopRecording() 
    mCamera->stopRecording();

}



void Camera::RecordingProxy::releaseRecordingFrame(const sp<IMemory>& mem)

{

    ALOGV("RecordingProxy::releaseRecordingFrame");

    mCamera->releaseRecordingFrame(mem);

}



void Camera::RecordingProxy::releaseRecordingFrameHandle(native_handle_t* handle) {

    ALOGV("RecordingProxy::releaseRecordingFrameHandle");

    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/ICameraRecordingProxy.cpp

+3 −91
Original line number Diff line number Diff line
@@ -18,7 +18,6 @@ 
#define LOG_TAG "ICameraRecordingProxy"

#include <camera/CameraUtils.h>

#include <camera/ICameraRecordingProxy.h>

#include <camera/ICameraRecordingProxyListener.h>

#include <binder/IMemory.h>

#include <binder/Parcel.h>

#include <media/hardware/HardwareAPI.h>
@@ -29,10 +28,7 @@ namespace android { 


enum {

    START_RECORDING = IBinder::FIRST_CALL_TRANSACTION,

    STOP_RECORDING,

    RELEASE_RECORDING_FRAME,

    RELEASE_RECORDING_FRAME_HANDLE,

    RELEASE_RECORDING_FRAME_HANDLE_BATCH,

    STOP_RECORDING

};
@@ -44,12 +40,11 @@ public: 
    {

    }



    status_t startRecording(const sp<ICameraRecordingProxyListener>& listener)

    status_t startRecording()

    {

        ALOGV("startRecording");

        Parcel data, reply;

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

        data.writeStrongBinder(IInterface::asBinder(listener));

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

        return reply.readInt32();

    }
@@ -61,46 +56,6 @@ public: 
        data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());

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

    }



    void releaseRecordingFrame(const sp<IMemory>& mem)

    {

        ALOGV("releaseRecordingFrame");

        Parcel data, reply;

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

        data.writeStrongBinder(IInterface::asBinder(mem));

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

    }



    void releaseRecordingFrameHandle(native_handle_t *handle) {

        ALOGV("releaseRecordingFrameHandle");

        Parcel data, reply;

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

        data.writeNativeHandle(handle);



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



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

        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");
@@ -114,9 +69,7 @@ status_t BnCameraRecordingProxy::onTransact( 
        case START_RECORDING: {

            ALOGV("START_RECORDING");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);

            sp<ICameraRecordingProxyListener> listener =

                interface_cast<ICameraRecordingProxyListener>(data.readStrongBinder());

            reply->writeInt32(startRecording(listener));

            reply->writeInt32(startRecording());

            return NO_ERROR;

        } break;

        case STOP_RECORDING: {
@@ -125,46 +78,6 @@ status_t BnCameraRecordingProxy::onTransact( 
            stopRecording();

            return NO_ERROR;

        } break;

        case RELEASE_RECORDING_FRAME: {

            ALOGV("RELEASE_RECORDING_FRAME");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);

            sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder());

            releaseRecordingFrame(mem);

            return NO_ERROR;

        } break;

        case RELEASE_RECORDING_FRAME_HANDLE: {

            ALOGV("RELEASE_RECORDING_FRAME_HANDLE");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);



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

            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);

    }
@@ -173,4 +86,3 @@ status_t BnCameraRecordingProxy::onTransact( 
// ----------------------------------------------------------------------------



}; // namespace android

camera/ICameraRecordingProxyListener.cpp

deleted100644 → 0
+0 −180
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2011 The Android Open Source Project

 *

 * 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.

 */



//#define LOG_NDEBUG 0

#define LOG_TAG "ICameraRecordingProxyListener"

#include <camera/CameraUtils.h>

#include <camera/ICameraRecordingProxyListener.h>

#include <binder/IMemory.h>

#include <binder/Parcel.h>

#include <media/hardware/HardwareAPI.h>

#include <utils/Log.h>



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>

{

public:

    explicit BpCameraRecordingProxyListener(const sp<IBinder>& impl)

        : BpInterface<ICameraRecordingProxyListener>(impl)

    {

    }



    void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& imageData)

    {

        ALOGV("dataCallback");

        Parcel data, reply;

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

        data.writeInt64(timestamp);

        data.writeInt32(msgType);

        data.writeStrongBinder(IInterface::asBinder(imageData));

        remote()->transact(DATA_CALLBACK_TIMESTAMP, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle) {

        ALOGV("recordingFrameHandleCallbackTimestamp");

        Parcel data, reply;

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

        data.writeInt64(timestamp);

        data.writeNativeHandle(handle);

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

                IBinder::FLAG_ONEWAY);



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

        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");



// ----------------------------------------------------------------------



status_t BnCameraRecordingProxyListener::onTransact(

    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

    switch(code) {

        case DATA_CALLBACK_TIMESTAMP: {

            ALOGV("DATA_CALLBACK_TIMESTAMP");

            CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);

            nsecs_t timestamp = data.readInt64();

            int32_t msgType = data.readInt32();

            sp<IMemory> imageData = interface_cast<IMemory>(data.readStrongBinder());

            dataCallbackTimestamp(timestamp, msgType, imageData);

            return NO_ERROR;

        } break;

        case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP: {

            ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP");

            CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);

            nsecs_t timestamp;

            status_t res = data.readInt64(&timestamp);

            if (res != OK) {

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

                return BAD_VALUE;

            }



            native_handle_t* handle = data.readNativeHandle();

            if (handle == nullptr) {

                ALOGE("%s: Received a null native handle", __FUNCTION__);

                return BAD_VALUE;

            }

            // The native handle will be freed in

            // BpCameraRecordingProxy::releaseRecordingFrameHandle.

            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++) {

                nsecs_t t;

                res = data.readInt64(&t);

                if (res != OK) {

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

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

                    return BAD_VALUE;

                }

                timestamps.push_back(t);

            }

            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);

    }

}



// ----------------------------------------------------------------------------



}; // namespace android

camera/include/camera/Camera.h

+1 −9
Original line number Diff line number Diff line
@@ -24,7 +24,6 @@ 
#include <gui/IGraphicBufferProducer.h>

#include <system/camera.h>

#include <camera/ICameraRecordingProxy.h>

#include <camera/ICameraRecordingProxyListener.h>

#include <camera/android/hardware/ICamera.h>

#include <camera/android/hardware/ICameraClient.h>

#include <camera/CameraBase.h>
@@ -150,7 +149,6 @@ public: 
            status_t    setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer);



            void        setListener(const sp<CameraListener>& listener);

            void        setRecordingProxyListener(const sp<ICameraRecordingProxyListener>& listener);



            // Configure preview callbacks to app. Only one of the older

            // callbacks or the callback surface can be active at the same time;
@@ -183,12 +181,8 @@ public: 
        explicit RecordingProxy(const sp<Camera>& camera);



        // ICameraRecordingProxy interface

        virtual status_t startRecording(const sp<ICameraRecordingProxyListener>& listener);

        virtual status_t startRecording();

        virtual void stopRecording();

        virtual void releaseRecordingFrame(const sp<IMemory>& mem);

        virtual void releaseRecordingFrameHandle(native_handle_t* handle);

        virtual void releaseRecordingFrameHandleBatch(

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



    private:

        sp<Camera>         mCamera;
@@ -199,8 +193,6 @@ protected: 
                        Camera(const Camera&);

                        Camera& operator=(const Camera);



    sp<ICameraRecordingProxyListener>  mRecordingProxyListener;



    friend class        CameraBase;

};