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

Commit c0ad82fa authored by Ivan Lozano's avatar Ivan Lozano
Browse files

Update language to comply with Android's inclusive language guidance 

See https://source.android.com/setup/contribute/respectful-code for reference

 #inclusivefixit

Bug: 161896447
Test: mma
Change-Id: Ib67ce35a9f313702f6f7229b3b91a392cf2ac0d8
parent 80f49ee7

services/camera/libcameraservice/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -52,7 +52,7 @@ cc_library_shared { 
        "device3/Camera3IOStreamBase.cpp",

        "device3/Camera3InputStream.cpp",

        "device3/Camera3OutputStream.cpp",

        "device3/Camera3DummyStream.cpp",

        "device3/Camera3FakeStream.cpp",

        "device3/Camera3SharedOutputStream.cpp",

        "device3/StatusTracker.cpp",

        "device3/Camera3BufferManager.cpp",

services/camera/libcameraservice/device3/Camera3Device.cpp

+37 −37
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ 
#include "device3/Camera3Device.h"

#include "device3/Camera3OutputStream.h"

#include "device3/Camera3InputStream.h"

#include "device3/Camera3DummyStream.h"

#include "device3/Camera3FakeStream.h"

#include "device3/Camera3SharedOutputStream.h"

#include "CameraService.h"

#include "utils/CameraThreadState.h"
@@ -309,7 +309,7 @@ status_t Camera3Device::initializeCommonLocked() { 


    internalUpdateStatusLocked(STATUS_UNCONFIGURED);

    mNextStreamId = 0;

    mDummyStreamId = NO_STREAM;

    mFakeStreamId = NO_STREAM;

    mNeedConfig = true;

    mPauseStateNotify = false;
@@ -2466,12 +2466,12 @@ status_t Camera3Device::configureStreamsLocked(int operatingMode, 
    }



    // Workaround for device HALv3.2 or older spec bug - zero streams requires

    // adding a dummy stream instead.

    // adding a fake stream instead.

    // TODO: Bug: 17321404 for fixing the HAL spec and removing this workaround.

    if (mOutputStreams.size() == 0) {

        addDummyStreamLocked();

        addFakeStreamLocked();

    } else {

        tryRemoveDummyStreamLocked();

        tryRemoveFakeStreamLocked();

    }



    // Start configuring the streams
@@ -2633,7 +2633,7 @@ status_t Camera3Device::configureStreamsLocked(int operatingMode, 


    mNeedConfig = false;



    internalUpdateStatusLocked((mDummyStreamId == NO_STREAM) ?

    internalUpdateStatusLocked((mFakeStreamId == NO_STREAM) ?

            STATUS_CONFIGURED : STATUS_UNCONFIGURED);



    ALOGV("%s: Camera %s: Stream configuration complete", __FUNCTION__, mId.string());
@@ -2647,69 +2647,69 @@ status_t Camera3Device::configureStreamsLocked(int operatingMode, 
        return rc;

    }



    if (mDummyStreamId == NO_STREAM) {

    if (mFakeStreamId == NO_STREAM) {

        mRequestBufferSM.onStreamsConfigured();

    }



    return OK;

}



status_t Camera3Device::addDummyStreamLocked() {

status_t Camera3Device::addFakeStreamLocked() {

    ATRACE_CALL();

    status_t res;



    if (mDummyStreamId != NO_STREAM) {

        // Should never be adding a second dummy stream when one is already

    if (mFakeStreamId != NO_STREAM) {

        // Should never be adding a second fake stream when one is already

        // active

        SET_ERR_L("%s: Camera %s: A dummy stream already exists!",

        SET_ERR_L("%s: Camera %s: A fake stream already exists!",

                __FUNCTION__, mId.string());

        return INVALID_OPERATION;

    }



    ALOGV("%s: Camera %s: Adding a dummy stream", __FUNCTION__, mId.string());

    ALOGV("%s: Camera %s: Adding a fake stream", __FUNCTION__, mId.string());



    sp<Camera3OutputStreamInterface> dummyStream =

            new Camera3DummyStream(mNextStreamId);

    sp<Camera3OutputStreamInterface> fakeStream =

            new Camera3FakeStream(mNextStreamId);



    res = mOutputStreams.add(mNextStreamId, dummyStream);

    res = mOutputStreams.add(mNextStreamId, fakeStream);

    if (res < 0) {

        SET_ERR_L("Can't add dummy stream to set: %s (%d)", strerror(-res), res);

        SET_ERR_L("Can't add fake stream to set: %s (%d)", strerror(-res), res);

        return res;

    }



    mDummyStreamId = mNextStreamId;

    mFakeStreamId = mNextStreamId;

    mNextStreamId++;



    return OK;

}



status_t Camera3Device::tryRemoveDummyStreamLocked() {

status_t Camera3Device::tryRemoveFakeStreamLocked() {

    ATRACE_CALL();

    status_t res;



    if (mDummyStreamId == NO_STREAM) return OK;

    if (mFakeStreamId == NO_STREAM) return OK;

    if (mOutputStreams.size() == 1) return OK;



    ALOGV("%s: Camera %s: Removing the dummy stream", __FUNCTION__, mId.string());

    ALOGV("%s: Camera %s: Removing the fake stream", __FUNCTION__, mId.string());



    // Ok, have a dummy stream and there's at least one other output stream,

    // so remove the dummy

    // Ok, have a fake stream and there's at least one other output stream,

    // so remove the fake



    sp<Camera3StreamInterface> deletedStream = mOutputStreams.get(mDummyStreamId);

    sp<Camera3StreamInterface> deletedStream = mOutputStreams.get(mFakeStreamId);

    if (deletedStream == nullptr) {

        SET_ERR_L("Dummy stream %d does not appear to exist", mDummyStreamId);

        SET_ERR_L("Fake stream %d does not appear to exist", mFakeStreamId);

        return INVALID_OPERATION;

    }

    mOutputStreams.remove(mDummyStreamId);

    mOutputStreams.remove(mFakeStreamId);



    // Free up the stream endpoint so that it can be used by some other stream

    res = deletedStream->disconnect();

    if (res != OK) {

        SET_ERR_L("Can't disconnect deleted dummy stream %d", mDummyStreamId);

        SET_ERR_L("Can't disconnect deleted fake stream %d", mFakeStreamId);

        // fall through since we want to still list the stream as deleted.

    }

    mDeletedStreams.add(deletedStream);

    mDummyStreamId = NO_STREAM;

    mFakeStreamId = NO_STREAM;



    return res;

}
@@ -2814,7 +2814,7 @@ void Camera3Device::onInflightEntryRemovedLocked(nsecs_t duration) { 
}



void Camera3Device::checkInflightMapLengthLocked() {

    // Sanity check - if we have too many in-flight frames with long total inflight duration,

    // Validation check - if we have too many in-flight frames with long total inflight duration,

    // something has likely gone wrong. This might still be legit only if application send in

    // a long burst of long exposure requests.

    if (mExpectedInflightDuration > kMinWarnInflightDuration) {
@@ -4405,11 +4405,11 @@ status_t Camera3Device::RequestThread::prepareHalRequests() { 
            std::set<std::string> cameraIdsWithZoom;

            /**

             * HAL workaround:

             * Insert a dummy trigger ID if a trigger is set but no trigger ID is

             * Insert a fake trigger ID if a trigger is set but no trigger ID is

             */

            res = addDummyTriggerIds(captureRequest);

            res = addFakeTriggerIds(captureRequest);

            if (res != OK) {

                SET_ERR("RequestThread: Unable to insert dummy trigger IDs "

                SET_ERR("RequestThread: Unable to insert fake trigger IDs "

                        "(capture request %d, HAL device: %s (%d)",

                        halRequest->frame_number, strerror(-res), res);

                return INVALID_OPERATION;
@@ -5313,26 +5313,26 @@ status_t Camera3Device::RequestThread::removeTriggers( 
    return OK;

}



status_t Camera3Device::RequestThread::addDummyTriggerIds(

status_t Camera3Device::RequestThread::addFakeTriggerIds(

        const sp<CaptureRequest> &request) {

    // Trigger ID 0 had special meaning in the HAL2 spec, so avoid it here

    static const int32_t dummyTriggerId = 1;

    static const int32_t fakeTriggerId = 1;

    status_t res;



    CameraMetadata &metadata = request->mSettingsList.begin()->metadata;



    // If AF trigger is active, insert a dummy AF trigger ID if none already

    // If AF trigger is active, insert a fake AF trigger ID if none already

    // exists

    camera_metadata_entry afTrigger = metadata.find(ANDROID_CONTROL_AF_TRIGGER);

    camera_metadata_entry afId = metadata.find(ANDROID_CONTROL_AF_TRIGGER_ID);

    if (afTrigger.count > 0 &&

            afTrigger.data.u8[0] != ANDROID_CONTROL_AF_TRIGGER_IDLE &&

            afId.count == 0) {

        res = metadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &dummyTriggerId, 1);

        res = metadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &fakeTriggerId, 1);

        if (res != OK) return res;

    }



    // If AE precapture trigger is active, insert a dummy precapture trigger ID

    // If AE precapture trigger is active, insert a fake precapture trigger ID

    // if none already exists

    camera_metadata_entry pcTrigger =

            metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER);
@@ -5341,7 +5341,7 @@ status_t Camera3Device::RequestThread::addDummyTriggerIds( 
            pcTrigger.data.u8[0] != ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE &&

            pcId.count == 0) {

        res = metadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID,

                &dummyTriggerId, 1);

                &fakeTriggerId, 1);

        if (res != OK) return res;

    }

services/camera/libcameraservice/device3/Camera3Device.h

+6 −6
Original line number Diff line number Diff line
@@ -474,7 +474,7 @@ class Camera3Device : 
    int                        mNextStreamId;

    bool                       mNeedConfig;



    int                        mDummyStreamId;

    int                        mFakeStreamId;



    // Whether to send state updates upstream

    // Pause when doing transparent reconfiguration
@@ -668,15 +668,15 @@ class Camera3Device : 
    void               cancelStreamsConfigurationLocked();



    /**

     * Add a dummy stream to the current stream set as a workaround for

     * Add a fake stream to the current stream set as a workaround for

     * not allowing 0 streams in the camera HAL spec.

     */

    status_t           addDummyStreamLocked();

    status_t           addFakeStreamLocked();



    /**

     * Remove a dummy stream if the current config includes real streams.

     * Remove a fake stream if the current config includes real streams.

     */

    status_t           tryRemoveDummyStreamLocked();

    status_t           tryRemoveFakeStreamLocked();



    /**

     * Set device into an error state due to some fatal failure, and set an
@@ -860,7 +860,7 @@ class Camera3Device : 


        // HAL workaround: Make sure a trigger ID always exists if

        // a trigger does

        status_t           addDummyTriggerIds(const sp<CaptureRequest> &request);

        status_t           addFakeTriggerIds(const sp<CaptureRequest> &request);



        // Override rotate_and_crop control if needed; returns true if the current value was changed

        bool               overrideAutoRotateAndCrop(const sp<CaptureRequest> &request);

services/camera/libcameraservice/device3/Camera3DummyStream.cpp→services/camera/libcameraservice/device3/Camera3FakeStream.cpp

+30 −30
Original line number Diff line number Diff line
@@ -14,47 +14,47 @@ 
 * limitations under the License.

 */



#define LOG_TAG "Camera3-DummyStream"

#define LOG_TAG "Camera3-FakeStream"

#define ATRACE_TAG ATRACE_TAG_CAMERA

//#define LOG_NDEBUG 0



#include <utils/Log.h>

#include <utils/Trace.h>

#include "Camera3DummyStream.h"

#include "Camera3FakeStream.h"



namespace android {



namespace camera3 {



const String8 Camera3DummyStream::DUMMY_ID;

const String8 Camera3FakeStream::FAKE_ID;



Camera3DummyStream::Camera3DummyStream(int id) :

        Camera3IOStreamBase(id, CAMERA3_STREAM_OUTPUT, DUMMY_WIDTH, DUMMY_HEIGHT,

                /*maxSize*/0, DUMMY_FORMAT, DUMMY_DATASPACE, DUMMY_ROTATION,

                DUMMY_ID) {

Camera3FakeStream::Camera3FakeStream(int id) :

        Camera3IOStreamBase(id, CAMERA3_STREAM_OUTPUT, FAKE_WIDTH, FAKE_HEIGHT,

                /*maxSize*/0, FAKE_FORMAT, FAKE_DATASPACE, FAKE_ROTATION,

                FAKE_ID) {



}



Camera3DummyStream::~Camera3DummyStream() {

Camera3FakeStream::~Camera3FakeStream() {



}



status_t Camera3DummyStream::getBufferLocked(camera3_stream_buffer *,

status_t Camera3FakeStream::getBufferLocked(camera3_stream_buffer *,

        const std::vector<size_t>&) {

    ATRACE_CALL();

    ALOGE("%s: Stream %d: Dummy stream cannot produce buffers!", __FUNCTION__, mId);

    ALOGE("%s: Stream %d: Fake stream cannot produce buffers!", __FUNCTION__, mId);

    return INVALID_OPERATION;

}



status_t Camera3DummyStream::returnBufferLocked(

status_t Camera3FakeStream::returnBufferLocked(

        const camera3_stream_buffer &,

        nsecs_t, const std::vector<size_t>&) {

    ATRACE_CALL();

    ALOGE("%s: Stream %d: Dummy stream cannot return buffers!", __FUNCTION__, mId);

    ALOGE("%s: Stream %d: Fake stream cannot return buffers!", __FUNCTION__, mId);

    return INVALID_OPERATION;

}



status_t Camera3DummyStream::returnBufferCheckedLocked(

status_t Camera3FakeStream::returnBufferCheckedLocked(

            const camera3_stream_buffer &,

            nsecs_t,

            bool,
@@ -62,71 +62,71 @@ status_t Camera3DummyStream::returnBufferCheckedLocked( 
            /*out*/

            sp<Fence>*) {

    ATRACE_CALL();

    ALOGE("%s: Stream %d: Dummy stream cannot return buffers!", __FUNCTION__, mId);

    ALOGE("%s: Stream %d: Fake stream cannot return buffers!", __FUNCTION__, mId);

    return INVALID_OPERATION;

}



void Camera3DummyStream::dump(int fd, const Vector<String16> &args) const {

void Camera3FakeStream::dump(int fd, const Vector<String16> &args) const {

    (void) args;

    String8 lines;

    lines.appendFormat("    Stream[%d]: Dummy\n", mId);

    lines.appendFormat("    Stream[%d]: Fake\n", mId);

    write(fd, lines.string(), lines.size());



    Camera3IOStreamBase::dump(fd, args);

}



status_t Camera3DummyStream::setTransform(int) {

status_t Camera3FakeStream::setTransform(int) {

    ATRACE_CALL();

    // Do nothing

    return OK;

}



status_t Camera3DummyStream::detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd) {

status_t Camera3FakeStream::detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd) {

    (void) buffer;

    (void) fenceFd;

    // Do nothing

    return OK;

}



status_t Camera3DummyStream::configureQueueLocked() {

status_t Camera3FakeStream::configureQueueLocked() {

    // Do nothing

    return OK;

}



status_t Camera3DummyStream::disconnectLocked() {

status_t Camera3FakeStream::disconnectLocked() {

    mState = (mState == STATE_IN_RECONFIG) ? STATE_IN_CONFIG

                                           : STATE_CONSTRUCTED;

    return OK;

}



status_t Camera3DummyStream::getEndpointUsage(uint64_t *usage) const {

    *usage = DUMMY_USAGE;

status_t Camera3FakeStream::getEndpointUsage(uint64_t *usage) const {

    *usage = FAKE_USAGE;

    return OK;

}



bool Camera3DummyStream::isVideoStream() const {

bool Camera3FakeStream::isVideoStream() const {

    return false;

}



bool Camera3DummyStream::isConsumerConfigurationDeferred(size_t /*surface_id*/) const {

bool Camera3FakeStream::isConsumerConfigurationDeferred(size_t /*surface_id*/) const {

    return false;

}



status_t Camera3DummyStream::dropBuffers(bool /*dropping*/) {

status_t Camera3FakeStream::dropBuffers(bool /*dropping*/) {

    return OK;

}



const String8& Camera3DummyStream::getPhysicalCameraId() const {

    return DUMMY_ID;

const String8& Camera3FakeStream::getPhysicalCameraId() const {

    return FAKE_ID;

}



status_t Camera3DummyStream::setConsumers(const std::vector<sp<Surface>>& /*consumers*/) {

    ALOGE("%s: Stream %d: Dummy stream doesn't support set consumer surface!",

status_t Camera3FakeStream::setConsumers(const std::vector<sp<Surface>>& /*consumers*/) {

    ALOGE("%s: Stream %d: Fake stream doesn't support set consumer surface!",

            __FUNCTION__, mId);

    return INVALID_OPERATION;

}



status_t Camera3DummyStream::updateStream(const std::vector<sp<Surface>> &/*outputSurfaces*/,

status_t Camera3FakeStream::updateStream(const std::vector<sp<Surface>> &/*outputSurfaces*/,

            const std::vector<OutputStreamInfo> &/*outputInfo*/,

            const std::vector<size_t> &/*removedSurfaceIds*/,

            KeyedVector<sp<Surface>, size_t> * /*outputMap*/) {

services/camera/libcameraservice/device3/Camera3DummyStream.h→services/camera/libcameraservice/device3/Camera3FakeStream.h

+17 −17
Original line number Diff line number Diff line
@@ -14,8 +14,8 @@ 
 * limitations under the License.

 */



#ifndef ANDROID_SERVERS_CAMERA3_DUMMY_STREAM_H

#define ANDROID_SERVERS_CAMERA3_DUMMY_STREAM_H

#ifndef ANDROID_SERVERS_CAMERA3_FAKE_STREAM_H

#define ANDROID_SERVERS_CAMERA3_FAKE_STREAM_H



#include <utils/RefBase.h>

#include <gui/Surface.h>
@@ -28,23 +28,23 @@ namespace android { 
namespace camera3 {



/**

 * A dummy output stream class, to be used as a placeholder when no valid

 * A fake output stream class, to be used as a placeholder when no valid

 * streams are configured by the client.

 * This is necessary because camera HAL v3.2 or older disallow configuring

 * 0 output streams, while the public camera2 API allows for it.

 */

class Camera3DummyStream :

class Camera3FakeStream :

        public Camera3IOStreamBase,

        public Camera3OutputStreamInterface {



  public:

    /**

     * Set up a dummy stream; doesn't actually connect to anything, and uses

     * a default dummy format and size.

     * Set up a fake stream; doesn't actually connect to anything, and uses

     * a default fake format and size.

     */

    explicit Camera3DummyStream(int id);

    explicit Camera3FakeStream(int id);



    virtual ~Camera3DummyStream();

    virtual ~Camera3FakeStream();



    /**

     * Camera3Stream interface
@@ -115,15 +115,15 @@ class Camera3DummyStream : 


  private:



    // Default dummy parameters; 320x240 is a required size for all devices,

    // Default fake parameters; 320x240 is a required size for all devices,

    // otherwise act like a SurfaceView would.

    static const int DUMMY_WIDTH = 320;

    static const int DUMMY_HEIGHT = 240;

    static const int DUMMY_FORMAT = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;

    static const android_dataspace DUMMY_DATASPACE = HAL_DATASPACE_UNKNOWN;

    static const camera3_stream_rotation_t DUMMY_ROTATION = CAMERA3_STREAM_ROTATION_0;

    static const uint64_t DUMMY_USAGE = GRALLOC_USAGE_HW_COMPOSER;

    static const String8 DUMMY_ID;

    static const int FAKE_WIDTH = 320;

    static const int FAKE_HEIGHT = 240;

    static const int FAKE_FORMAT = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;

    static const android_dataspace FAKE_DATASPACE = HAL_DATASPACE_UNKNOWN;

    static const camera3_stream_rotation_t FAKE_ROTATION = CAMERA3_STREAM_ROTATION_0;

    static const uint64_t FAKE_USAGE = GRALLOC_USAGE_HW_COMPOSER;

    static const String8 FAKE_ID;



    /**

     * Internal Camera3Stream interface
@@ -138,7 +138,7 @@ class Camera3DummyStream : 


    virtual status_t getEndpointUsage(uint64_t *usage) const;



}; // class Camera3DummyStream

}; // class Camera3FakeStream



} // namespace camera3