Snap for 5645017 from e0092766d214720c1fd22b8c08ccc7ceeaf4a700 to qt-release (c6e8e0f0) · Commits · e / devices / smdk4412 / android_frameworks_av

camera/ndk/ndk_vendor/impl/ACameraDevice.cpp

+27 −49

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

	#include "ACameraCaptureSession.inc"		#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;		using namespace android;

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

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

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

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

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

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

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

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

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

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

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

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

	return utils::convertFromHidl(remoteRet);
	}		}

	void		void

media/extractors/mp4/MPEG4Extractor.cpp

+64 −68

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

	// If format type is 'alac', it is necessary to get the parameters		if (!mIsQT && original_fourcc == FOURCC("alac")) {
	// from a alac atom spreading behind the frma atom.		off64_t tmpOffset = *offset;
	// See 'external/alac/ALACMagicCookieDescription.txt'.		status_t err = parseALACSampleEntry(&tmpOffset);
	if (original_fourcc == FOURCC("alac")) {		if (err != OK) {
	// Store ALAC magic cookie (decoder needs it).		ALOGE("parseALACSampleEntry err:%d Line:%d", err, __LINE__);
	uint8_t alacInfo[12];		return err;
	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]);		*offset = tmpOffset + 8;
	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));

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

	@@ -1653,7 +1624,18 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) {
	case 0x6D730055: // "ms U" mp3 audio		case 0x6D730055: // "ms U" mp3 audio
	{		{
	if (mIsQT && depth >= 1 && mPath[depth - 1] == FOURCC("wave")) {		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		// Ignore all atoms embedded in QT wave atom
			ALOGV("Ignore all atoms embedded in QT wave atom");
	*offset += chunk_size;		*offset += chunk_size;
	break;		break;
	}		}
	@@ -1792,39 +1774,14 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) {
	CHECK_EQ(*offset, stop_offset);		CHECK_EQ(*offset, stop_offset);
	}		}

	if (chunk_type == FOURCC("alac")) {		if (!mIsQT && chunk_type == FOURCC("alac")) {

	// See 'external/alac/ALACMagicCookieDescription.txt for the detail'.
	// Store ALAC magic cookie (decoder needs it).
	uint8_t alacInfo[12];
	data_offset += sizeof(buffer);		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];		status_t err = parseALACSampleEntry(&data_offset);
	AMediaFormat_setInt32(mLastTrack->meta,		if (err != OK) {
	AMEDIAFORMAT_KEY_BITS_PER_SAMPLE, bitsPerSample);		ALOGE("parseALACSampleEntry err:%d Line:%d", err, __LINE__);
	AMediaFormat_setInt32(mLastTrack->meta,		return err;
	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;		*offset = data_offset;
	CHECK_EQ(*offset, stop_offset);		CHECK_EQ(*offset, stop_offset);
	}		}
	@@ -3289,6 +3246,45 @@ status_t MPEG4Extractor::parseAC3SpecificBox(off64_t offset) {
	return OK;		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) {		status_t MPEG4Extractor::parseSegmentIndex(off64_t offset, size_t size) {
	ALOGV("MPEG4Extractor::parseSegmentIndex");		ALOGV("MPEG4Extractor::parseSegmentIndex");

media/extractors/mp4/MPEG4Extractor.h

+1 −0

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

	MPEG4Extractor(const MPEG4Extractor &);		MPEG4Extractor(const MPEG4Extractor &);

media/libmediaplayerservice/nuplayer/GenericSource.cpp

+37 −10

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

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

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

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

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

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

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

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

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

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

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

			mDisconnectLock.unlock();

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

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

			mCachedSource.clear();

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

media/libmediaplayerservice/nuplayer/GenericSource.h

+1 −0

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

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

	sp<ALooper> mLooper;		sp<ALooper> mLooper;