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

Commit 6af7e11e authored by Ivan Lozano's avatar Ivan Lozano Committed by Android (Google) Code Review
Browse files

Merge "Update language to comply with Android's inclusive language guidance"

parents 7aa2e4a5 c0ad82fa

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