Snap for 5647767 from aefeb2ab9ea6556cffcbd902db8c1c181c19bca8 to qt-c2f2-release (6460cc58) · Commits · e / os / android_frameworks_av

camera/ndk/ndk_vendor/impl/ACameraDevice.cpp

+27 −49

Original line number	Diff line number	Diff line
		@@ -31,6 +31,17 @@

		#include "ACameraCaptureSession.inc"

		#define CHECK_TRANSACTION_AND_RET(remoteRet, status, callName) \
		if (!remoteRet.isOk()) { \
		ALOGE("%s: Transaction error during %s call %s", __FUNCTION__, callName, \
		remoteRet.description().c_str()); \
		return ACAMERA_ERROR_UNKNOWN; \
		} \
		if (status != Status::NO_ERROR) { \
		ALOGE("%s: %s call failed", __FUNCTION__, callName); \
		return utils::convertFromHidl(status); \
		}

		using namespace android;

		namespace android {
		@@ -151,7 +162,7 @@ CameraDevice::createCaptureRequest(
		return ACAMERA_ERROR_CAMERA_DISCONNECTED;
		}
		CameraMetadata rawRequest;
		Status status = Status::NO_ERROR;
		Status status = Status::UNKNOWN_ERROR;
		auto remoteRet = mRemote->createDefaultRequest(
		utils::convertToHidl(templateId),
		[&status, &rawRequest](auto s, const hidl_vec<uint8_t> &metadata) {
		@@ -161,14 +172,7 @@ CameraDevice::createCaptureRequest(
		ALOGE("%s: Couldn't create default request", __FUNCTION__);
		}
		});
		if (!remoteRet.isOk()) {
		ALOGE("%s: Transaction error while trying to create default request %s", __FUNCTION__,
		remoteRet.description().c_str());
		return ACAMERA_ERROR_UNKNOWN;
		}
		if (status != Status::NO_ERROR) {
		return utils::convertFromHidl(status);
		}
		CHECK_TRANSACTION_AND_RET(remoteRet, status, "createDefaultRequest()")
		ACaptureRequest* outReq = new ACaptureRequest();
		outReq->settings = new ACameraMetadata(rawRequest.release(), ACameraMetadata::ACM_REQUEST);
		if (physicalCameraIdList != nullptr) {
		@@ -243,21 +247,16 @@ camera_status_t CameraDevice::isSessionConfigurationSupported(
		}

		bool configSupported = false;
		Status status = Status::NO_ERROR;
		Status status = Status::UNKNOWN_ERROR;
		auto remoteRet = mRemote->isSessionConfigurationSupported(sessionConfig,
		[&status, &configSupported](auto s, auto supported) {
		status = s;
		configSupported = supported;
		});

		if (status == Status::INVALID_OPERATION) {
		return ACAMERA_ERROR_UNSUPPORTED_OPERATION;
		} else if (!remoteRet.isOk()) {
		return ACAMERA_ERROR_UNKNOWN;
		} else {
		CHECK_TRANSACTION_AND_RET(remoteRet, status, "isSessionConfigurationSupported()");
		return configSupported ? ACAMERA_OK : ACAMERA_ERROR_STREAM_CONFIGURE_FAIL;
		}
		}

		static void addMetadataToPhysicalCameraSettings(const CameraMetadata *metadata,
		const std::string &cameraId, PhysicalCameraSettings *physicalCameraSettings) {
		@@ -525,16 +524,13 @@ CameraDevice::stopRepeatingLocked() {
		mRepeatingSequenceId = REQUEST_ID_NONE;

		int64_t lastFrameNumber;
		Status status = Status::NO_ERROR;
		Status status = Status::UNKNOWN_ERROR;
		auto remoteRet = mRemote->cancelRepeatingRequest(
		[&status, &lastFrameNumber](Status s, auto frameNumber) {
		status = s;
		lastFrameNumber = frameNumber;
		});
		if (!remoteRet.isOk() \|\| status != Status::NO_ERROR) {
		ALOGE("%s: Unable to cancel active repeating request", __FUNCTION__);
		return utils::convertFromHidl(status);
		}
		CHECK_TRANSACTION_AND_RET(remoteRet, status, "cancelRepeatingRequest()");
		checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber);
		}
		return ACAMERA_OK;
		@@ -582,15 +578,12 @@ CameraDevice::flushLocked(ACameraCaptureSession* session) {
		}

		int64_t lastFrameNumber;
		Status status;
		Status status = Status::UNKNOWN_ERROR;
		auto remoteRet = mRemote->flush([&status, &lastFrameNumber](auto s, auto frameNumber) {
		status = s;
		lastFrameNumber = frameNumber;
		});
		if (!remoteRet.isOk() \|\| status != Status::NO_ERROR) {
		ALOGE("%s: Abort captures failed", __FUNCTION__);
		return utils::convertFromHidl(status);
		}
		CHECK_TRANSACTION_AND_RET(remoteRet, status, "flush()")
		if (mRepeatingSequenceId != REQUEST_ID_NONE) {
		checkRepeatingSequenceCompleteLocked(mRepeatingSequenceId, lastFrameNumber);
		}
		@@ -611,10 +604,7 @@ CameraDevice::waitUntilIdleLocked() {
		}

		auto remoteRet = mRemote->waitUntilIdle();
		if (!remoteRet.isOk()) {
		ALOGE("%s: Transaction waitUntilIdle failed", __FUNCTION__);
		return utils::convertFromHidl(remoteRet);
		}
		CHECK_TRANSACTION_AND_RET(remoteRet, remoteRet, "waitUntilIdle()")
		return ACAMERA_OK;
		}

		@@ -689,34 +679,25 @@ CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outpu
		mIdle = true;

		auto remoteRet = mRemote->beginConfigure();
		if (!remoteRet.isOk()\|\| remoteRet != Status::NO_ERROR) {
		ALOGE("Camera device %s begin configure failed", getId());
		return utils::convertFromHidl(remoteRet);
		}
		CHECK_TRANSACTION_AND_RET(remoteRet, remoteRet, "beginConfigure()")

		// delete to-be-deleted streams
		for (auto streamId : deleteList) {
		remoteRet = mRemote->deleteStream(streamId);
		if (!remoteRet.isOk() \|\| remoteRet != Status::NO_ERROR) {
		ALOGE("Camera device %s failed to remove stream %d", getId(), streamId);
		return utils::convertFromHidl(remoteRet);
		}
		CHECK_TRANSACTION_AND_RET(remoteRet, remoteRet, "deleteStream()")
		mConfiguredOutputs.erase(streamId);
		}

		// add new streams
		for (auto outputPair : addSet) {
		int streamId;
		Status status;
		Status status = Status::UNKNOWN_ERROR;
		auto ret = mRemote->createStream(outputPair.second,
		[&status, &streamId](Status s, auto stream_id) {
		status = s;
		streamId = stream_id;
		});
		if (!remoteRet.isOk() \|\| status != Status::NO_ERROR) {
		ALOGE("Camera device %s failed to create stream", getId());
		return utils::convertFromHidl(status);
		}
		CHECK_TRANSACTION_AND_RET(ret, status, "createStream()")
		mConfiguredOutputs.insert(std::make_pair(streamId, outputPair));
		}

		@@ -729,11 +710,8 @@ CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outpu
		params.unlock(params_metadata);
		}
		remoteRet = mRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE, hidlParams);
		if (!remoteRet.isOk()) {
		ALOGE("Transaction error: endConfigure failed %s", remoteRet.description().c_str());
		}

		return utils::convertFromHidl(remoteRet);
		CHECK_TRANSACTION_AND_RET(remoteRet, remoteRet, "endConfigure()")
		return ACAMERA_OK;
		}

		void

media/extractors/mp4/MPEG4Extractor.cpp

+64 −68

Original line number	Diff line number	Diff line
		@@ -1197,45 +1197,16 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) {
		AMEDIAFORMAT_KEY_SAMPLE_RATE, sample_rate);
		}

		// If format type is 'alac', it is necessary to get the parameters
		// from a alac atom spreading behind the frma atom.
		// See 'external/alac/ALACMagicCookieDescription.txt'.
		if (original_fourcc == FOURCC("alac")) {
		// Store ALAC magic cookie (decoder needs it).
		uint8_t alacInfo[12];
		data_offset = *offset;
		if (mDataSource->readAt(
		data_offset, alacInfo, sizeof(alacInfo)) < (ssize_t)sizeof(alacInfo)) {
		return ERROR_IO;
		if (!mIsQT && original_fourcc == FOURCC("alac")) {
		off64_t tmpOffset = *offset;
		status_t err = parseALACSampleEntry(&tmpOffset);
		if (err != OK) {
		ALOGE("parseALACSampleEntry err:%d Line:%d", err, __LINE__);
		return err;
		}
		uint32_t size = U32_AT(&alacInfo[0]);
		if ((size != ALAC_SPECIFIC_INFO_SIZE) \|\|
		(U32_AT(&alacInfo[4]) != FOURCC("alac")) \|\|
		(U32_AT(&alacInfo[8]) != 0)) {
		return ERROR_MALFORMED;
		*offset = tmpOffset + 8;
		}

		data_offset += sizeof(alacInfo);
		uint8_t cookie[size - sizeof(alacInfo)];
		if (mDataSource->readAt(
		data_offset, cookie, sizeof(cookie)) < (ssize_t)sizeof(cookie)) {
		return ERROR_IO;
		}

		uint8_t bitsPerSample = cookie[5];
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_BITS_PER_SAMPLE, bitsPerSample);
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_CHANNEL_COUNT, cookie[9]);
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_SAMPLE_RATE, U32_AT(&cookie[20]));
		AMediaFormat_setBuffer(mLastTrack->meta,
		AMEDIAFORMAT_KEY_CSD_0, cookie, sizeof(cookie));

		// Add the size of ALAC Specific Info (36 bytes) and terminator
		// atom (8 bytes).
		*offset += (size + 8);
		}
		break;
		}

		@@ -1653,7 +1624,18 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) {
		case 0x6D730055: // "ms U" mp3 audio
		{
		if (mIsQT && depth >= 1 && mPath[depth - 1] == FOURCC("wave")) {

		if (chunk_type == FOURCC("alac")) {
		off64_t offsetTmp = *offset;
		status_t err = parseALACSampleEntry(&offsetTmp);
		if (err != OK) {
		ALOGE("parseALACSampleEntry err:%d Line:%d", err, __LINE__);
		return err;
		}
		}

		// Ignore all atoms embedded in QT wave atom
		ALOGV("Ignore all atoms embedded in QT wave atom");
		*offset += chunk_size;
		break;
		}
		@@ -1792,39 +1774,14 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) {
		CHECK_EQ(*offset, stop_offset);
		}

		if (chunk_type == FOURCC("alac")) {

		// See 'external/alac/ALACMagicCookieDescription.txt for the detail'.
		// Store ALAC magic cookie (decoder needs it).
		uint8_t alacInfo[12];
		if (!mIsQT && chunk_type == FOURCC("alac")) {
		data_offset += sizeof(buffer);
		if (mDataSource->readAt(
		data_offset, alacInfo, sizeof(alacInfo)) < (ssize_t)sizeof(alacInfo)) {
		return ERROR_IO;
		}
		uint32_t size = U32_AT(&alacInfo[0]);
		if ((size != ALAC_SPECIFIC_INFO_SIZE) \|\|
		(U32_AT(&alacInfo[4]) != FOURCC("alac")) \|\|
		(U32_AT(&alacInfo[8]) != 0)) {
		return ERROR_MALFORMED;
		}
		data_offset += sizeof(alacInfo);
		uint8_t cookie[size - sizeof(alacInfo)];
		if (mDataSource->readAt(
		data_offset, cookie, sizeof(cookie)) < (ssize_t)sizeof(cookie)) {
		return ERROR_IO;
		}

		uint8_t bitsPerSample = cookie[5];
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_BITS_PER_SAMPLE, bitsPerSample);
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_CHANNEL_COUNT, cookie[9]);
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_SAMPLE_RATE, U32_AT(&cookie[20]));
		AMediaFormat_setBuffer(mLastTrack->meta,
		AMEDIAFORMAT_KEY_CSD_0, cookie, sizeof(cookie));
		data_offset += sizeof(cookie);
		status_t err = parseALACSampleEntry(&data_offset);
		if (err != OK) {
		ALOGE("parseALACSampleEntry err:%d Line:%d", err, __LINE__);
		return err;
		}
		*offset = data_offset;
		CHECK_EQ(*offset, stop_offset);
		}
		@@ -3289,6 +3246,45 @@ status_t MPEG4Extractor::parseAC3SpecificBox(off64_t offset) {
		return OK;
		}

		status_t MPEG4Extractor::parseALACSampleEntry(off64_t *offset) {
		// See 'external/alac/ALACMagicCookieDescription.txt for the detail'.
		// Store ALAC magic cookie (decoder needs it).
		uint8_t alacInfo[12];
		off64_t data_offset = *offset;

		if (mDataSource->readAt(
		data_offset, alacInfo, sizeof(alacInfo)) < (ssize_t)sizeof(alacInfo)) {
		return ERROR_IO;
		}
		uint32_t size = U32_AT(&alacInfo[0]);
		if ((size != ALAC_SPECIFIC_INFO_SIZE) \|\|
		(U32_AT(&alacInfo[4]) != FOURCC("alac")) \|\|
		(U32_AT(&alacInfo[8]) != 0)) {
		ALOGV("Size:%u, U32_AT(&alacInfo[4]):%u, U32_AT(&alacInfo[8]):%u",
		size, U32_AT(&alacInfo[4]), U32_AT(&alacInfo[8]));
		return ERROR_MALFORMED;
		}
		data_offset += sizeof(alacInfo);
		uint8_t cookie[size - sizeof(alacInfo)];
		if (mDataSource->readAt(
		data_offset, cookie, sizeof(cookie)) < (ssize_t)sizeof(cookie)) {
		return ERROR_IO;
		}

		uint8_t bitsPerSample = cookie[5];
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_BITS_PER_SAMPLE, bitsPerSample);
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_CHANNEL_COUNT, cookie[9]);
		AMediaFormat_setInt32(mLastTrack->meta,
		AMEDIAFORMAT_KEY_SAMPLE_RATE, U32_AT(&cookie[20]));
		AMediaFormat_setBuffer(mLastTrack->meta,
		AMEDIAFORMAT_KEY_CSD_0, cookie, sizeof(cookie));
		data_offset += sizeof(cookie);
		*offset = data_offset;
		return OK;
		}

		status_t MPEG4Extractor::parseSegmentIndex(off64_t offset, size_t size) {
		ALOGV("MPEG4Extractor::parseSegmentIndex");

media/extractors/mp4/MPEG4Extractor.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -179,6 +179,7 @@ private:
		status_t parseAC3SpecificBox(off64_t offset);
		status_t parseEAC3SpecificBox(off64_t offset);
		status_t parseAC4SpecificBox(off64_t offset);
		status_t parseALACSampleEntry(off64_t *offset);
		void adjustRawDefaultFrameSize();

		MPEG4Extractor(const MPEG4Extractor &);

media/libmediaplayerservice/nuplayer/GenericSource.cpp

+37 −10

Original line number	Diff line number	Diff line
		@@ -90,8 +90,11 @@ void NuPlayer::GenericSource::resetDataSource() {
		ALOGV("resetDataSource");

		mHTTPService.clear();
		{
		Mutex::Autolock _l_d(mDisconnectLock);
		mHttpSource.clear();
		mDisconnected = false;
		}
		mUri.clear();
		mUriHeaders.clear();
		mSources.clear();
		@@ -152,7 +155,10 @@ status_t NuPlayer::GenericSource::setDataSource(const sp<DataSource>& source) {
		ALOGV("setDataSource (source: %p)", source.get());

		resetDataSource();
		{
		Mutex::Autolock _l_d(mDisconnectLock);
		mDataSource = source;
		}
		return OK;
		}

		@@ -163,8 +169,12 @@ sp<MetaData> NuPlayer::GenericSource::getFileFormatMeta() const {

		status_t NuPlayer::GenericSource::initFromDataSource() {
		sp<IMediaExtractor> extractor;
		CHECK(mDataSource != NULL);
		sp<DataSource> dataSource = mDataSource;
		sp<DataSource> dataSource;
		{
		Mutex::Autolock _l_d(mDisconnectLock);
		dataSource = mDataSource;
		}
		CHECK(dataSource != NULL);

		mLock.unlock();
		// This might take long time if data source is not reliable.
		@@ -359,6 +369,7 @@ void NuPlayer::GenericSource::prepareAsync() {
		}

		void NuPlayer::GenericSource::onPrepareAsync() {
		mDisconnectLock.lock();
		ALOGV("onPrepareAsync: mDataSource: %d", (mDataSource != NULL));

		// delayed data source creation
		@@ -372,20 +383,30 @@ void NuPlayer::GenericSource::onPrepareAsync() {
		String8 contentType;

		if (!strncasecmp("http://", uri, 7) \|\| !strncasecmp("https://", uri, 8)) {
		mHttpSource = DataSourceFactory::CreateMediaHTTP(mHTTPService);
		if (mHttpSource == NULL) {
		sp<DataSource> httpSource;
		mDisconnectLock.unlock();
		httpSource = DataSourceFactory::CreateMediaHTTP(mHTTPService);
		if (httpSource == NULL) {
		ALOGE("Failed to create http source!");
		notifyPreparedAndCleanup(UNKNOWN_ERROR);
		mDisconnectLock.lock();
		return;
		}
		mDisconnectLock.lock();

		if (!mDisconnected) {
		mHttpSource = httpSource;
		}
		}

		mLock.unlock();
		mDisconnectLock.unlock();
		// This might take long time if connection has some issue.
		sp<DataSource> dataSource = DataSourceFactory::CreateFromURI(
		mHTTPService, uri, &mUriHeaders, &contentType,
		static_cast<HTTPBase *>(mHttpSource.get()));
		mLock.lock();
		mDisconnectLock.lock();
		if (!mDisconnected) {
		mDataSource = dataSource;
		}
		@@ -437,6 +458,8 @@ void NuPlayer::GenericSource::onPrepareAsync() {
		mCachedSource = static_cast<NuCachedSource2 *>(mDataSource.get());
		}

		mDisconnectLock.unlock();

		// For cached streaming cases, we need to wait for enough
		// buffering before reporting prepared.
		mIsStreaming = (mCachedSource != NULL);
		@@ -503,9 +526,13 @@ void NuPlayer::GenericSource::finishPrepareAsync() {

		void NuPlayer::GenericSource::notifyPreparedAndCleanup(status_t err) {
		if (err != OK) {
		{
		Mutex::Autolock _l_d(mDisconnectLock);
		mDataSource.clear();
		mCachedSource.clear();
		mHttpSource.clear();
		}

		mCachedSource.clear();

		mBitrate = -1;
		mPrevBufferPercentage = -1;
		@@ -547,7 +574,7 @@ void NuPlayer::GenericSource::resume() {
		void NuPlayer::GenericSource::disconnect() {
		sp<DataSource> dataSource, httpSource;
		{
		Mutex::Autolock _l(mLock);
		Mutex::Autolock _l_d(mDisconnectLock);
		dataSource = mDataSource;
		httpSource = mHttpSource;
		mDisconnected = true;

media/libmediaplayerservice/nuplayer/GenericSource.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -170,6 +170,7 @@ private:
		sp<ABuffer> mGlobalTimedText;

		mutable Mutex mLock;
		mutable Mutex mDisconnectLock; // Protects mDataSource, mHttpSource and mDisconnected

		sp<ALooper> mLooper;