Merge "Distinguish discontinuities w/ a format change from those without." (70119929) · Commits · e / os / android_frameworks_base

media/libmediaplayerservice/nuplayer/NuPlayer.cpp

+52 −18

Original line number	Original line	Diff line number	Diff line
	@@ -32,8 +32,6 @@
	#include <media/stagefright/MetaData.h>		#include <media/stagefright/MetaData.h>
	#include <surfaceflinger/Surface.h>		#include <surfaceflinger/Surface.h>

	#define SHUTDOWN_ON_DISCONTINUITY 0

	namespace android {		namespace android {

	////////////////////////////////////////////////////////////////////////////////		////////////////////////////////////////////////////////////////////////////////
	@@ -78,6 +76,26 @@ void NuPlayer::start() {
	(new AMessage(kWhatStart, id()))->post();		(new AMessage(kWhatStart, id()))->post();
	}		}

			// static
			bool NuPlayer::IsFlushingState(FlushStatus state, bool *formatChange) {
			switch (state) {
			case FLUSHING_DECODER:
			if (formatChange != NULL) {
			*formatChange = false;
			}
			return true;

			case FLUSHING_DECODER_FORMATCHANGE:
			if (formatChange != NULL) {
			*formatChange = true;
			}
			return true;

			default:
			return false;
			}
			}

	void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {		void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
	switch (msg->what()) {		switch (msg->what()) {
	case kWhatSetDataSource:		case kWhatSetDataSource:
	@@ -181,17 +199,19 @@ void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
	} else if (what == ACodec::kWhatEOS) {		} else if (what == ACodec::kWhatEOS) {
	mRenderer->queueEOS(audio, ERROR_END_OF_STREAM);		mRenderer->queueEOS(audio, ERROR_END_OF_STREAM);
	} else if (what == ACodec::kWhatFlushCompleted) {		} else if (what == ACodec::kWhatFlushCompleted) {
			bool formatChange;

	if (audio) {		if (audio) {
	CHECK_EQ((int)mFlushingAudio, (int)FLUSHING_DECODER);		CHECK(IsFlushingState(mFlushingAudio, &formatChange));
	mFlushingAudio = FLUSHED;		mFlushingAudio = FLUSHED;
	} else {		} else {
	CHECK_EQ((int)mFlushingVideo, (int)FLUSHING_DECODER);		CHECK(IsFlushingState(mFlushingVideo, &formatChange));
	mFlushingVideo = FLUSHED;		mFlushingVideo = FLUSHED;
	}		}

	LOGI("decoder %s flush completed", audio ? "audio" : "video");		LOGI("decoder %s flush completed", audio ? "audio" : "video");

	#if SHUTDOWN_ON_DISCONTINUITY		if (formatChange) {
	LOGI("initiating %s decoder shutdown",		LOGI("initiating %s decoder shutdown",
	audio ? "audio" : "video");		audio ? "audio" : "video");

	@@ -202,7 +222,7 @@ void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
	} else {		} else {
	mFlushingVideo = SHUTTING_DOWN_DECODER;		mFlushingVideo = SHUTTING_DOWN_DECODER;
	}		}
	#endif		}

	finishFlushIfPossible();		finishFlushIfPossible();
	} else if (what == ACodec::kWhatOutputFormatChanged) {		} else if (what == ACodec::kWhatOutputFormatChanged) {
	@@ -451,8 +471,8 @@ status_t NuPlayer::feedDecoderInputData(bool audio, const sp<AMessage> &msg) {
	sp<AMessage> reply;		sp<AMessage> reply;
	CHECK(msg->findMessage("reply", &reply));		CHECK(msg->findMessage("reply", &reply));

	if ((audio && mFlushingAudio == FLUSHING_DECODER)		if ((audio && IsFlushingState(mFlushingAudio))
	\|\| (!audio && mFlushingVideo == FLUSHING_DECODER)) {		\|\| (!audio && IsFlushingState(mFlushingVideo))) {
	reply->setInt32("err", INFO_DISCONTINUITY);		reply->setInt32("err", INFO_DISCONTINUITY);
	reply->post();		reply->post();
	return OK;		return OK;
	@@ -467,14 +487,25 @@ status_t NuPlayer::feedDecoderInputData(bool audio, const sp<AMessage> &msg) {
	return err;		return err;
	} else if (err != OK) {		} else if (err != OK) {
	if (err == INFO_DISCONTINUITY) {		if (err == INFO_DISCONTINUITY) {
	LOGI("%s discontinuity", audio ? "audio" : "video");		int32_t formatChange;
			if (!accessUnit->meta()->findInt32(
			"format-change", &formatChange)) {
			formatChange = 0;
			}

			LOGI("%s discontinuity (formatChange=%d)",
			audio ? "audio" : "video", formatChange);

	(audio ? mAudioDecoder : mVideoDecoder)->signalFlush();		(audio ? mAudioDecoder : mVideoDecoder)->signalFlush();
	mRenderer->flush(audio);		mRenderer->flush(audio);

	if (audio) {		if (audio) {
	CHECK(mFlushingAudio == NONE		CHECK(mFlushingAudio == NONE
	\|\| mFlushingAudio == AWAITING_DISCONTINUITY);		\|\| mFlushingAudio == AWAITING_DISCONTINUITY);
	mFlushingAudio = FLUSHING_DECODER;
			mFlushingAudio = formatChange
			? FLUSHING_DECODER_FORMATCHANGE : FLUSHING_DECODER;

	if (mFlushingVideo == NONE) {		if (mFlushingVideo == NONE) {
	mFlushingVideo = (mVideoDecoder != NULL)		mFlushingVideo = (mVideoDecoder != NULL)
	? AWAITING_DISCONTINUITY		? AWAITING_DISCONTINUITY
	@@ -483,7 +514,10 @@ status_t NuPlayer::feedDecoderInputData(bool audio, const sp<AMessage> &msg) {
	} else {		} else {
	CHECK(mFlushingVideo == NONE		CHECK(mFlushingVideo == NONE
	\|\| mFlushingVideo == AWAITING_DISCONTINUITY);		\|\| mFlushingVideo == AWAITING_DISCONTINUITY);
	mFlushingVideo = FLUSHING_DECODER;
			mFlushingVideo = formatChange
			? FLUSHING_DECODER_FORMATCHANGE : FLUSHING_DECODER;

	if (mFlushingAudio == NONE) {		if (mFlushingAudio == NONE) {
	mFlushingAudio = (mAudioDecoder != NULL)		mFlushingAudio = (mAudioDecoder != NULL)
	? AWAITING_DISCONTINUITY		? AWAITING_DISCONTINUITY

media/libmediaplayerservice/nuplayer/NuPlayer.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -79,6 +79,7 @@ private:
	NONE,		NONE,
	AWAITING_DISCONTINUITY,		AWAITING_DISCONTINUITY,
	FLUSHING_DECODER,		FLUSHING_DECODER,
			FLUSHING_DECODER_FORMATCHANGE,
	SHUTTING_DOWN_DECODER,		SHUTTING_DOWN_DECODER,
	FLUSHED,		FLUSHED,
	SHUT_DOWN,		SHUT_DOWN,
	@@ -104,6 +105,8 @@ private:

	void finishFlushIfPossible();		void finishFlushIfPossible();

			static bool IsFlushingState(FlushStatus state, bool *formatChange = NULL);

	DISALLOW_EVIL_CONSTRUCTORS(NuPlayer);		DISALLOW_EVIL_CONSTRUCTORS(NuPlayer);
	};		};

media/libstagefright/mpeg2ts/ATSParser.cpp

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -334,7 +334,7 @@ void ATSParser::Stream::signalDiscontinuity(DiscontinuityType type) {

	if (mStreamType == 0x1b && mSource != NULL) {		if (mStreamType == 0x1b && mSource != NULL) {
	// Don't signal discontinuities on audio streams.		// Don't signal discontinuities on audio streams.
	mSource->queueDiscontinuity();		mSource->queueDiscontinuity(true /* formatChange */);
	}		}
	break;		break;
	}		}
	@@ -348,7 +348,7 @@ void ATSParser::Stream::signalDiscontinuity(DiscontinuityType type) {

	if (mSource != NULL) {		if (mSource != NULL) {
	mSource->clear();		mSource->clear();
	mSource->queueDiscontinuity();		mSource->queueDiscontinuity(!isASeek);
	}		}
	break;		break;
	}		}

media/libstagefright/mpeg2ts/AnotherPacketSource.cpp

+5 −3

Original line number	Original line	Diff line number	Diff line
	@@ -63,8 +63,6 @@ status_t AnotherPacketSource::dequeueAccessUnit(sp<ABuffer> *buffer) {
	int32_t discontinuity;		int32_t discontinuity;
	if ((*buffer)->meta()->findInt32("discontinuity", &discontinuity)		if ((*buffer)->meta()->findInt32("discontinuity", &discontinuity)
	&& discontinuity) {		&& discontinuity) {
	buffer->clear();

	return INFO_DISCONTINUITY;		return INFO_DISCONTINUITY;
	}		}

	@@ -125,10 +123,14 @@ void AnotherPacketSource::queueAccessUnit(const sp<ABuffer> &buffer) {
	mCondition.signal();		mCondition.signal();
	}		}

	void AnotherPacketSource::queueDiscontinuity() {		void AnotherPacketSource::queueDiscontinuity(bool formatChange) {
	sp<ABuffer> buffer = new ABuffer(0);		sp<ABuffer> buffer = new ABuffer(0);
	buffer->meta()->setInt32("discontinuity", true);		buffer->meta()->setInt32("discontinuity", true);

			if (formatChange) {
			buffer->meta()->setInt32("format-change", true);
			}

	Mutex::Autolock autoLock(mLock);		Mutex::Autolock autoLock(mLock);

	mBuffers.push_back(buffer);		mBuffers.push_back(buffer);

media/libstagefright/mpeg2ts/AnotherPacketSource.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -42,7 +42,7 @@ struct AnotherPacketSource : public MediaSource {
	status_t nextBufferTime(int64_t *timeUs);		status_t nextBufferTime(int64_t *timeUs);

	void queueAccessUnit(const sp<ABuffer> &buffer);		void queueAccessUnit(const sp<ABuffer> &buffer);
	void queueDiscontinuity();		void queueDiscontinuity(bool formatChange);
	void signalEOS(status_t result);		void signalEOS(status_t result);

	void clear();		void clear();