Snap for 13135932 from 9da0b43fc3b83997da4c4162b7d76056a7372b74 to 25Q2-release (7d3a329e) · Commits · e / os / android_frameworks_av

camera/ndk/impl/ACameraCaptureSession.cpp

+4 −1

Original line number	Diff line number	Diff line
		@@ -97,6 +97,7 @@ ACameraCaptureSession::stopRepeating() {
		dev->lockDeviceForSessionOps();
		{
		if (dev->isSharedMode() && !dev->isPrimaryClient()) {
		dev->unlockDevice();
		return ACAMERA_ERROR_UNSUPPORTED_OPERATION;
		}
		Mutex::Autolock _l(mSessionLock);
		@@ -138,11 +139,11 @@ ACameraCaptureSession::abortCaptures() {
		ALOGE("Error: Device associated with session %p has been closed!", this);
		return ACAMERA_ERROR_SESSION_CLOSED;
		}

		camera_status_t ret;
		dev->lockDeviceForSessionOps();
		{
		if (dev->isSharedMode() && !dev->isPrimaryClient()) {
		dev->unlockDevice();
		return ACAMERA_ERROR_UNSUPPORTED_OPERATION;
		}
		Mutex::Autolock _l(mSessionLock);
		@@ -167,6 +168,7 @@ camera_status_t ACameraCaptureSession::updateOutputConfiguration(ACaptureSession
		dev->lockDeviceForSessionOps();
		{
		if (dev->isSharedMode()) {
		dev->unlockDevice();
		return ACAMERA_ERROR_UNSUPPORTED_OPERATION;
		}
		Mutex::Autolock _l(mSessionLock);
		@@ -191,6 +193,7 @@ camera_status_t ACameraCaptureSession::prepare(ANativeWindow* window) {
		dev->lockDeviceForSessionOps();
		{
		if (dev->isSharedMode()) {
		dev->unlockDevice();
		return ACAMERA_ERROR_UNSUPPORTED_OPERATION;
		}
		Mutex::Autolock _l(mSessionLock);

camera/ndk/impl/ACameraDevice.cpp

+5 −0

Original line number	Diff line number	Diff line
		@@ -711,6 +711,11 @@ CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outpu
		if (ret != ACAMERA_OK) {
		return ret;
		}
		// Surface sharing cannot be enabled when a camera has been opened
		// in shared mode.
		if (flags::camera_multi_client() && mSharedMode && outConfig.mIsShared) {
		return ACAMERA_ERROR_INVALID_PARAMETER;
		}
		ParcelableSurfaceType pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
		outputSet.insert(std::make_pair(
		anw,

media/audio/aconfig/audio.aconfig

+7 −0

Original line number	Diff line number	Diff line
		@@ -101,6 +101,13 @@ flag {
		bug: "376480814"
		}

		flag {
		name: "hardening_partial_volume"
		namespace: "media_audio"
		description: "Flag for partial enforcement of volume hardening"
		bug: "376480814"
		}

		flag {
		name: "hardening_strict"
		is_exported: true

media/libmediametrics/Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -16,7 +16,8 @@ cc_library {
		name: "libmediametrics",

		srcs: [
		"ItemSerialization.cpp",
		"ItemSerialize-ByteString.cpp",
		"ItemSerialize-Parcel.cpp",
		"MediaMetrics.cpp",
		"MediaMetricsItem.cpp",
		],

media/libmediametrics/ItemSerialization.cpp→media/libmediametrics/ItemSerialize-ByteString.cpp

+0 −125

Original line number	Diff line number	Diff line
		@@ -22,7 +22,6 @@
		#include <sys/endian.h>
		#include <sys/types.h>

		#include <binder/Parcel.h>
		#include <cutils/multiuser.h>
		#include <cutils/properties.h>
		#include <utils/Errors.h>
		@@ -30,9 +29,6 @@
		#include <utils/SortedVector.h>
		#include <utils/threads.h>

		#include <android/media/BnMediaMetricsService.h> // for direct Binder access
		#include <android/media/IMediaMetricsService.h>
		#include <binder/IServiceManager.h>
		#include <media/MediaMetricsItem.h>
		#include <private/android_filesystem_config.h>

		@@ -42,81 +38,6 @@ static constexpr size_t kMaxPropertyStringSize = 4096;

		namespace android::mediametrics {

		// Parcel / serialize things for binder calls
		//

		status_t mediametrics::Item::readFromParcel(const Parcel& data) {
		int32_t version;
		status_t status = data.readInt32(&version);
		if (status != NO_ERROR) return status;

		switch (version) {
		case 0:
		return readFromParcel0(data);
		default:
		ALOGE("%s: unsupported parcel version: %d", __func__, version);
		return INVALID_OPERATION;
		}
		}

		status_t mediametrics::Item::readFromParcel0(const Parcel& data) {
		mKey = std::string{data.readString8()};
		int32_t pid, uid;
		status_t status = data.readInt32(&pid) ?: data.readInt32(&uid);
		if (status != NO_ERROR) return status;
		mPid = (pid_t)pid;
		mUid = (uid_t)uid;
		mPkgName = std::string(data.readString8());
		int32_t count;
		int64_t version, timestamp;
		status = data.readInt64(&version) ?: data.readInt64(&timestamp) ?: data.readInt32(&count);
		if (status != NO_ERROR) return status;
		if (count < 0) return BAD_VALUE;
		mPkgVersionCode = version;
		mTimestamp = timestamp;
		for (int i = 0; i < count; i++) {
		Prop prop;
		status_t status = prop.readFromParcel(data);
		if (status != NO_ERROR) return status;
		mProps[prop.getName()] = std::move(prop);
		}
		return NO_ERROR;
		}

		status_t mediametrics::Item::writeToParcel(Parcel *data) const {
		if (data == nullptr) return BAD_VALUE;

		const int32_t version = 0;
		status_t status = data->writeInt32(version);
		if (status != NO_ERROR) return status;

		switch (version) {
		case 0:
		return writeToParcel0(data);
		default:
		ALOGE("%s: unsupported parcel version: %d", __func__, version);
		return INVALID_OPERATION;
		}
		}

		status_t mediametrics::Item::writeToParcel0(Parcel *data) const {
		status_t status =
		data->writeString8(String8{mKey})
		?: data->writeInt32(mPid)
		?: data->writeInt32(mUid)
		?: data->writeString8(String8{mPkgName})
		?: data->writeInt64(mPkgVersionCode)
		?: data->writeInt64(mTimestamp);
		if (status != NO_ERROR) return status;

		data->writeInt32((int32_t)mProps.size());
		for (auto &prop : *this) {
		status = prop.writeToParcel(data);
		if (status != NO_ERROR) return status;
		}
		return NO_ERROR;
		}

		status_t mediametrics::Item::writeToByteString(char *pbuffer, size_t plength) const
		{
		if (pbuffer == nullptr \|\| plength == nullptr)
		@@ -264,52 +185,6 @@ status_t mediametrics::Item::readFromByteString(const char *bufferptr, size_t le
		return NO_ERROR;
		}

		status_t mediametrics::Item::Prop::readFromParcel(const Parcel& data)
		{
		const std::string key {data.readString8()};
		int32_t type;
		status_t status = data.readInt32(&type);
		if (status != NO_ERROR) return status;
		switch (type) {
		case mediametrics::kTypeInt32: {
		int32_t value;
		status = data.readInt32(&value);
		if (status != NO_ERROR) return status;
		mElem = value;
		} break;
		case mediametrics::kTypeInt64: {
		int64_t value;
		status = data.readInt64(&value);
		if (status != NO_ERROR) return status;
		mElem = value;
		} break;
		case mediametrics::kTypeDouble: {
		double value;
		status = data.readDouble(&value);
		if (status != NO_ERROR) return status;
		mElem = value;
		} break;
		case mediametrics::kTypeCString: {
		mElem = std::string{data.readString8()};
		} break;
		case mediametrics::kTypeRate: {
		std::pair<int64_t, int64_t> rate;
		status = data.readInt64(&rate.first)
		?: data.readInt64(&rate.second);
		if (status != NO_ERROR) return status;
		mElem = rate;
		} break;
		case mediametrics::kTypeNone: {
		mElem = std::monostate{};
		} break;
		default:
		ALOGE("%s: reading bad item type: %d", __func__, type);
		return BAD_VALUE;
		}
		setName(key);
		return NO_ERROR;
		}

		status_t mediametrics::Item::Prop::readFromByteString(
		const char *bufferpptr, const char bufferptrmax)
		{