Merge "Use view::Surface instead of IGBPs in OutputConfiguration" into main (c759762e) · Commits · e / os / android_frameworks_av

camera/camera2/CaptureRequest.cpp

+9 −1

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#include <camera/StringUtils.h>

		#include <binder/Parcel.h>
		#include <gui/Flags.h> // remove with WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		#include <gui/Surface.h>
		#include <gui/view/Surface.h>

		@@ -112,11 +113,14 @@ status_t CaptureRequest::readFromParcel(const android::Parcel* parcel) {
		return err;
		}

		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		sp<Surface> surface = surfaceShim.toSurface();
		#else
		sp<Surface> surface;
		if (surfaceShim.graphicBufferProducer != NULL) {
		surface = new Surface(surfaceShim.graphicBufferProducer);
		}

		#endif
		mSurfaceList.push_back(surface);
		}

		@@ -206,9 +210,13 @@ status_t CaptureRequest::writeToParcel(android::Parcel* parcel) const {
		parcel->writeString16(String16("android.view.Surface"));

		// Surface.writeToParcel
		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		view::Surface surfaceShim = view::Surface::fromSurface(mSurfaceList[i]);
		#else
		view::Surface surfaceShim;
		surfaceShim.name = String16("unknown_name");
		surfaceShim.graphicBufferProducer = mSurfaceList[i]->getIGraphicBufferProducer();
		#endif
		if ((err = surfaceShim.writeToParcel(parcel)) != OK) {
		ALOGE("%s: Failed to write output target Surface %d to parcel: %s (%d)",
		__FUNCTION__, i, strerror(-err), err);

camera/camera2/OutputConfiguration.cpp

+34 −35

Original line number	Diff line number	Diff line
		@@ -37,9 +37,8 @@ const int OutputConfiguration::INVALID_ROTATION = -1;
		const int OutputConfiguration::ROTATION_0 = 0;
		const int OutputConfiguration::INVALID_SET_ID = -1;

		const std::vector<sp<IGraphicBufferProducer>>&
		OutputConfiguration::getGraphicBufferProducers() const {
		return mGbps;
		const std::vector<ParcelableSurfaceType>& OutputConfiguration::getSurfaces() const {
		return mSurfaces;
		}

		int OutputConfiguration::getRotation() const {
		@@ -102,24 +101,23 @@ int OutputConfiguration::getMirrorMode() const {
		return mMirrorMode;
		}

		int OutputConfiguration::getMirrorMode(sp<IGraphicBufferProducer> surface) const {
		int OutputConfiguration::getMirrorMode(ParcelableSurfaceType surface) const {
		if (!flags::mirror_mode_shared_surfaces()) {
		return mMirrorMode;
		}

		if (mGbps.size() != mMirrorModeForProducers.size()) {
		ALOGE("%s: mGbps size doesn't match mMirrorModeForProducers: %zu vs %zu",
		__FUNCTION__, mGbps.size(), mMirrorModeForProducers.size());
		if (mSurfaces.size() != mMirrorModeForProducers.size()) {
		ALOGE("%s: mSurfaces size doesn't match mMirrorModeForProducers: %zu vs %zu",
		__FUNCTION__, mSurfaces.size(), mMirrorModeForProducers.size());
		return mMirrorMode;
		}

		// Use per-producer mirror mode if available.
		for (size_t i = 0; i < mGbps.size(); i++) {
		if (mGbps[i] == surface) {
		for (size_t i = 0; i < mSurfaces.size(); i++) {
		if (mSurfaces[i] == surface) {
		return mMirrorModeForProducers[i];
		}
		}

		// For surface that doesn't belong to this output configuration, use
		// mMirrorMode as default.
		ALOGW("%s: Surface doesn't belong to this OutputConfiguration!", __FUNCTION__);
		@@ -146,7 +144,7 @@ bool OutputConfiguration::isComplete() const {
		return !((mSurfaceType == SURFACE_TYPE_MEDIA_RECORDER \|\|
		mSurfaceType == SURFACE_TYPE_MEDIA_CODEC \|\|
		mSurfaceType == SURFACE_TYPE_IMAGE_READER) &&
		mGbps.empty());
		mSurfaces.empty());
		}

		OutputConfiguration::OutputConfiguration() :
		@@ -348,7 +346,7 @@ status_t OutputConfiguration::readFromParcel(const android::Parcel* parcel) {
		ALOGV("%s: OutputConfiguration: %p, name %s", __FUNCTION__,
		surface.graphicBufferProducer.get(),
		toString8(surface.name).c_str());
		mGbps.push_back(surface.graphicBufferProducer);
		mSurfaces.push_back(flagtools::toParcelableSurfaceType(surface));
		}

		mSensorPixelModesUsed = std::move(sensorPixelModesUsed);
		@@ -369,10 +367,10 @@ status_t OutputConfiguration::readFromParcel(const android::Parcel* parcel) {
		return err;
		}

		OutputConfiguration::OutputConfiguration(sp<IGraphicBufferProducer>& gbp, int rotation,
		OutputConfiguration::OutputConfiguration(ParcelableSurfaceType& surface, int rotation,
		const std::string& physicalId,
		int surfaceSetID, bool isShared) {
		mGbps.push_back(gbp);
		mSurfaces.push_back(surface);
		mRotation = rotation;
		mSurfaceSetID = surfaceSetID;
		mIsDeferred = false;
		@@ -392,17 +390,17 @@ OutputConfiguration::OutputConfiguration(sp<IGraphicBufferProducer>& gbp, int ro
		}

		OutputConfiguration::OutputConfiguration(
		const std::vector<sp<IGraphicBufferProducer>>& gbps,
		const std::vector<ParcelableSurfaceType>& surfaces,
		int rotation, const std::string& physicalCameraId, int surfaceSetID, int surfaceType,
		int width, int height, bool isShared)
		: mGbps(gbps), mRotation(rotation), mSurfaceSetID(surfaceSetID), mSurfaceType(surfaceType),
		mWidth(width), mHeight(height), mIsDeferred(false), mIsShared(isShared),
		mPhysicalCameraId(physicalCameraId), mIsMultiResolution(false),
		: mSurfaces(surfaces), mRotation(rotation), mSurfaceSetID(surfaceSetID),
		mSurfaceType(surfaceType), mWidth(width), mHeight(height), mIsDeferred(false),
		mIsShared(isShared), mPhysicalCameraId(physicalCameraId), mIsMultiResolution(false),
		mDynamicRangeProfile(ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD),
		mColorSpace(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED),
		mStreamUseCase(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT),
		mTimestampBase(TIMESTAMP_BASE_DEFAULT),
		mMirrorMode(MIRROR_MODE_AUTO), mMirrorModeForProducers(gbps.size(), mMirrorMode),
		mMirrorMode(MIRROR_MODE_AUTO), mMirrorModeForProducers(surfaces.size(), mMirrorMode),
		mUseReadoutTimestamp(false), mFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
		mDataspace(0), mUsage(0) { }

		@@ -432,14 +430,18 @@ status_t OutputConfiguration::writeToParcel(android::Parcel* parcel) const {
		err = parcel->writeInt32(mIsShared ? 1 : 0);
		if (err != OK) return err;

		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		err = parcel->writeParcelableVector(mSurfaces);
		#else
		std::vector<view::Surface> surfaceShims;
		for (auto& gbp : mGbps) {
		for (auto& gbp : mSurfaces) {
		view::Surface surfaceShim;
		surfaceShim.name = String16("unknown_name"); // name of surface
		surfaceShim.graphicBufferProducer = gbp;
		surfaceShims.push_back(surfaceShim);
		}
		err = parcel->writeParcelableVector(surfaceShims);
		#endif
		if (err != OK) return err;

		String16 physicalCameraId = toString16(mPhysicalCameraId);
		@@ -513,10 +515,9 @@ static bool simpleVectorsLessThan(T first, T second) {
		return false;
		}

		bool OutputConfiguration::gbpsEqual(const OutputConfiguration& other) const {
		const std::vector<sp<IGraphicBufferProducer> >& otherGbps =
		other.getGraphicBufferProducers();
		return simpleVectorsEqual(otherGbps, mGbps);
		bool OutputConfiguration::surfacesEqual(const OutputConfiguration& other) const {
		const std::vector<ParcelableSurfaceType>& otherSurfaces = other.getSurfaces();
		return simpleVectorsEqual(otherSurfaces, mSurfaces);
		}

		bool OutputConfiguration::sensorPixelModesUsedEqual(const OutputConfiguration& other) const {
		@@ -527,7 +528,6 @@ bool OutputConfiguration::sensorPixelModesUsedEqual(const OutputConfiguration& o
		bool OutputConfiguration::mirrorModesEqual(const OutputConfiguration& other) const {
		const std::vector<int>& otherMirrorModes = other.getMirrorModes();
		return simpleVectorsEqual(otherMirrorModes, mMirrorModeForProducers);

		}

		bool OutputConfiguration::sensorPixelModesUsedLessThan(const OutputConfiguration& other) const {
		@@ -540,17 +540,16 @@ bool OutputConfiguration::mirrorModesLessThan(const OutputConfiguration& other)
		return simpleVectorsLessThan(mMirrorModeForProducers, otherMirrorModes);
		}

		bool OutputConfiguration::gbpsLessThan(const OutputConfiguration& other) const {
		const std::vector<sp<IGraphicBufferProducer> >& otherGbps =
		other.getGraphicBufferProducers();
		bool OutputConfiguration::surfacesLessThan(const OutputConfiguration& other) const {
		const std::vector<ParcelableSurfaceType>& otherSurfaces = other.getSurfaces();

		if (mGbps.size() != otherGbps.size()) {
		return mGbps.size() < otherGbps.size();
		if (mSurfaces.size() != otherSurfaces.size()) {
		return mSurfaces.size() < otherSurfaces.size();
		}

		for (size_t i = 0; i < mGbps.size(); i++) {
		if (mGbps[i] != otherGbps[i]) {
		return mGbps[i] < otherGbps[i];
		for (size_t i = 0; i < mSurfaces.size(); i++) {
		if (mSurfaces[i] != otherSurfaces[i]) {
		return mSurfaces[i] < otherSurfaces[i];
		}
		}

camera/include/camera/android/hardware/ICamera.h

+7 −2

Original line number	Diff line number	Diff line
		@@ -34,8 +34,13 @@ namespace hardware {

		class ICameraClient;

		class ICamera: public android::IInterface
		{
		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		typedef Surface ProducerType;
		#else
		typedef IGraphicBufferProducer ProducerType;
		#endif

		class ICamera : public android::IInterface {
		/**
		* Keep up-to-date with ICamera.aidl in frameworks/base
		*/

camera/include/camera/camera2/OutputConfiguration.h

+18 −10

Original line number	Diff line number	Diff line
		@@ -19,7 +19,12 @@

		#include <string>

		#include <gui/Flags.h> // remove with WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		#include <gui/view/Surface.h>
		#else
		#include <gui/IGraphicBufferProducer.h>
		#endif
		#include <binder/Parcelable.h>

		namespace android {
		@@ -59,7 +64,7 @@ public:
		MIRROR_MODE_V = 3,
		};

		const std::vector<sp<IGraphicBufferProducer>>& getGraphicBufferProducers() const;
		const std::vector<ParcelableSurfaceType>& getSurfaces() const;
		int getRotation() const;
		int getSurfaceSetID() const;
		int getSurfaceType() const;
		@@ -73,7 +78,7 @@ public:
		bool isMultiResolution() const;
		int64_t getStreamUseCase() const;
		int getTimestampBase() const;
		int getMirrorMode(sp<IGraphicBufferProducer> surface) const;
		int getMirrorMode(ParcelableSurfaceType surface) const;
		int getMirrorMode() const;
		bool useReadoutTimestamp() const;
		int getFormat() const;
		@@ -100,11 +105,11 @@ public:
		// getSurfaceSetID will be INVALID_SET_ID if error occurred
		OutputConfiguration(const android::Parcel& parcel);

		OutputConfiguration(sp<IGraphicBufferProducer>& gbp, int rotation,
		OutputConfiguration(ParcelableSurfaceType& surface, int rotation,
		const std::string& physicalCameraId,
		int surfaceSetID = INVALID_SET_ID, bool isShared = false);

		OutputConfiguration(const std::vector<sp<IGraphicBufferProducer>>& gbps,
		OutputConfiguration(const std::vector<ParcelableSurfaceType>& surfaces,
		int rotation, const std::string& physicalCameraId,
		int surfaceSetID = INVALID_SET_ID,
		int surfaceType = SURFACE_TYPE_UNKNOWN, int width = 0,
		@@ -121,7 +126,7 @@ public:
		mHeight == other.mHeight &&
		mIsDeferred == other.mIsDeferred &&
		mIsShared == other.mIsShared &&
		gbpsEqual(other) &&
		surfacesEqual(other) &&
		mPhysicalCameraId == other.mPhysicalCameraId &&
		mIsMultiResolution == other.mIsMultiResolution &&
		sensorPixelModesUsedEqual(other) &&
		@@ -201,18 +206,21 @@ public:
		if (mUsage != other.mUsage) {
		return mUsage < other.mUsage;
		}
		return gbpsLessThan(other);
		return surfacesLessThan(other);
		}

		bool operator > (const OutputConfiguration& other) const {
		return (this != other && !(this < other));
		}

		bool gbpsEqual(const OutputConfiguration& other) const;
		bool surfacesEqual(const OutputConfiguration& other) const;
		bool sensorPixelModesUsedEqual(const OutputConfiguration& other) const;
		bool sensorPixelModesUsedLessThan(const OutputConfiguration& other) const;
		bool gbpsLessThan(const OutputConfiguration& other) const;
		void addGraphicProducer(sp<IGraphicBufferProducer> gbp) {mGbps.push_back(gbp);}
		bool surfacesLessThan(const OutputConfiguration& other) const;
		void addSurface(ParcelableSurfaceType surface) { mSurfaces.push_back(surface); }
		#if not WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		void addGraphicProducer(sp<IGraphicBufferProducer> gbp) {addSurface(gbp);}
		#endif
		bool mirrorModesEqual(const OutputConfiguration& other) const;
		bool mirrorModesLessThan(const OutputConfiguration& other) const;
		const std::vector<int32_t>& getMirrorModes() const {return mMirrorModeForProducers;}
		@@ -239,7 +247,7 @@ public:
		}

		private:
		std::vector<sp<IGraphicBufferProducer>> mGbps;
		std::vector<ParcelableSurfaceType> mSurfaces;
		int mRotation;
		int mSurfaceSetID;
		int mSurfaceType;

camera/ndk/impl/ACameraDevice.cpp

+33 −26

Original line number	Diff line number	Diff line
		@@ -231,25 +231,27 @@ camera_status_t CameraDevice::isSessionConfigurationSupported(
		SessionConfiguration sessionConfiguration(0 /inputWidth/, 0 /inputHeight/,
		-1 /inputFormat/, CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE);
		for (const auto& output : sessionOutputContainer->mOutputs) {
		sp<IGraphicBufferProducer> iGBP(nullptr);
		ret = getIGBPfromAnw(output.mWindow, iGBP);
		sp<SurfaceType> surface(nullptr);
		ret = getSurfacefromAnw(output.mWindow, surface);
		if (ret != ACAMERA_OK) {
		ALOGE("Camera device %s failed to extract graphic producer from native window",
		getId());
		return ret;
		}

		OutputConfiguration outConfig(iGBP, output.mRotation, output.mPhysicalCameraId,
		ParcelableSurfaceType pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
		OutputConfiguration outConfig(pSurface, output.mRotation, output.mPhysicalCameraId,
		OutputConfiguration::INVALID_SET_ID, true);

		for (auto& anw : output.mSharedWindows) {
		ret = getIGBPfromAnw(anw, iGBP);
		ret = getSurfacefromAnw(anw, surface);
		if (ret != ACAMERA_OK) {
		ALOGE("Camera device %s failed to extract graphic producer from native window",
		getId());
		return ret;
		}
		outConfig.addGraphicProducer(iGBP);
		pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
		outConfig.addSurface(pSurface);
		}

		sessionConfiguration.addOutputConfiguration(outConfig);
		@@ -295,25 +297,27 @@ camera_status_t CameraDevice::updateOutputConfigurationLocked(ACaptureSessionOut
		return ACAMERA_ERROR_INVALID_PARAMETER;
		}

		sp<IGraphicBufferProducer> iGBP(nullptr);
		ret = getIGBPfromAnw(output->mWindow, iGBP);
		sp<SurfaceType> surface(nullptr);
		ret = getSurfacefromAnw(output->mWindow, surface);
		if (ret != ACAMERA_OK) {
		ALOGE("Camera device %s failed to extract graphic producer from native window",
		getId());
		return ret;
		}

		OutputConfiguration outConfig(iGBP, output->mRotation, output->mPhysicalCameraId,
		ParcelableSurfaceType pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
		OutputConfiguration outConfig(pSurface, output->mRotation, output->mPhysicalCameraId,
		OutputConfiguration::INVALID_SET_ID, true);

		for (auto& anw : output->mSharedWindows) {
		ret = getIGBPfromAnw(anw, iGBP);
		ret = getSurfacefromAnw(anw, surface);
		if (ret != ACAMERA_OK) {
		ALOGE("Camera device %s failed to extract graphic producer from native window",
		getId());
		return ret;
		}
		outConfig.addGraphicProducer(iGBP);
		pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
		outConfig.addSurface(pSurface);
		}

		auto remoteRet = mRemote->updateOutputConfiguration(streamId, outConfig);
		@@ -427,9 +431,9 @@ CameraDevice::allocateCaptureRequest(
		for (const auto& kvPair : mConfiguredOutputs) {
		int streamId = kvPair.first;
		const OutputConfiguration& outConfig = kvPair.second.second;
		const auto& gbps = outConfig.getGraphicBufferProducers();
		for (int surfaceId = 0; surfaceId < (int) gbps.size(); surfaceId++) {
		if (gbps[surfaceId] == surface->getIGraphicBufferProducer()) {
		const auto& surfaces = outConfig.getSurfaces();
		for (int surfaceId = 0; surfaceId < (int)surfaces.size(); surfaceId++) {
		if (surfaces[surfaceId] == flagtools::surfaceToSurfaceType(surface)) {
		found = true;
		req->mStreamIdxList.push_back(streamId);
		req->mSurfaceIdxList.push_back(surfaceId);
		@@ -634,16 +638,13 @@ CameraDevice::waitUntilIdleLocked() {
		return ACAMERA_OK;
		}

		camera_status_t
		CameraDevice::getIGBPfromAnw(
		ANativeWindow* anw,
		sp<IGraphicBufferProducer>& out) {
		camera_status_t CameraDevice::getSurfacefromAnw(ANativeWindow* anw, sp<SurfaceType>& out) {
		sp<Surface> surface;
		camera_status_t ret = getSurfaceFromANativeWindow(anw, surface);
		if (ret != ACAMERA_OK) {
		return ret;
		}
		out = surface->getIGraphicBufferProducer();
		out = flagtools::surfaceToSurfaceType(surface);
		return ACAMERA_OK;
		}

		@@ -681,13 +682,15 @@ CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outpu
		std::set<std::pair<ANativeWindow*, OutputConfiguration>> outputSet;
		for (const auto& outConfig : outputs->mOutputs) {
		ANativeWindow* anw = outConfig.mWindow;
		sp<IGraphicBufferProducer> iGBP(nullptr);
		ret = getIGBPfromAnw(anw, iGBP);
		sp<SurfaceType> surface(nullptr);
		ret = getSurfacefromAnw(anw, surface);
		if (ret != ACAMERA_OK) {
		return ret;
		}
		ParcelableSurfaceType pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
		outputSet.insert(std::make_pair(
		anw, OutputConfiguration(iGBP, outConfig.mRotation, outConfig.mPhysicalCameraId,
		anw,
		OutputConfiguration(pSurface, outConfig.mRotation, outConfig.mPhysicalCameraId,
		OutputConfiguration::INVALID_SET_ID, outConfig.mIsShared)));
		}
		auto addSet = outputSet;
		@@ -885,10 +888,14 @@ CameraDevice::onCaptureErrorLocked(
		return;
		}

		const auto& gbps = outputPairIt->second.second.getGraphicBufferProducers();
		for (const auto& outGbp : gbps) {
		const auto& outSurfaces = outputPairIt->second.second.getSurfaces();
		for (const auto& outSurface : outSurfaces) {
		for (const auto& surface : request->mSurfaceList) {
		if (surface->getIGraphicBufferProducer() == outGbp) {
		if ( outSurface == surface
		#if not WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		->getIGraphicBufferProducer()
		#endif
		) {
		ANativeWindow* anw = static_cast<ANativeWindow*>(surface.get());
		ALOGV("Camera %s Lost output buffer for ANW %p frame %" PRId64,
		getId(), anw, frameNumber);