stagefright: Remove deprecated AwesomePlayer (e4d40ad9) · Commits · e / os / android_frameworks_av

include/media/stagefright/AudioPlayer.h

+1 −3

Original line number	Diff line number	Diff line
		@@ -46,8 +46,7 @@ public:
		};

		AudioPlayer(const sp<MediaPlayerBase::AudioSink> &audioSink,
		uint32_t flags = 0,
		AwesomePlayer *audioObserver = NULL);
		uint32_t flags = 0);

		virtual ~AudioPlayer();

		@@ -109,7 +108,6 @@ private:
		MediaBuffer *mFirstBuffer;

		sp<MediaPlayerBase::AudioSink> mAudioSink;
		AwesomePlayer *mObserver;
		int64_t mPinnedTimeUs;

		bool mPlaying;

media/libmediaplayerservice/Android.mk

+1 −1

Original line number	Diff line number	Diff line
		@@ -18,7 +18,6 @@ LOCAL_SRC_FILES:= \
		MetadataRetrieverClient.cpp \
		RemoteDisplay.cpp \
		SharedLibrary.cpp \
		StagefrightPlayer.cpp \
		StagefrightRecorder.cpp \
		TestPlayerStub.cpp \

		@@ -45,6 +44,7 @@ LOCAL_SHARED_LIBRARIES := \
		LOCAL_STATIC_LIBRARIES := \
		libstagefright_nuplayer \
		libstagefright_rtsp \
		libstagefright_timedtext \

		LOCAL_C_INCLUDES := \
		$(TOP)/frameworks/av/media/libstagefright/include \

media/libmediaplayerservice/MediaPlayerFactory.cpp

+0 −65

Original line number	Diff line number	Diff line
		@@ -31,7 +31,6 @@
		#include "MediaPlayerFactory.h"

		#include "TestPlayerStub.h"
		#include "StagefrightPlayer.h"
		#include "nuplayer/NuPlayerDriver.h"

		namespace android {
		@@ -64,12 +63,6 @@ status_t MediaPlayerFactory::registerFactory_l(IFactory* factory,
		}

		static player_type getDefaultPlayerType() {
		char value[PROPERTY_VALUE_MAX];
		if (property_get("media.stagefright.use-awesome", value, NULL)
		&& (!strcmp("1", value) \|\| !strcasecmp("true", value))) {
		return STAGEFRIGHT_PLAYER;
		}

		return NU_PLAYER;
		}

		@@ -176,63 +169,6 @@ sp<MediaPlayerBase> MediaPlayerFactory::createPlayer(
		* *
		*****************************************************************************/

		class StagefrightPlayerFactory :
		public MediaPlayerFactory::IFactory {
		public:
		virtual float scoreFactory(const sp<IMediaPlayer>& /client/,
		int fd,
		int64_t offset,
		int64_t length,
		float /curScore/) {
		if (legacyDrm()) {
		sp<DataSource> source = new FileSource(dup(fd), offset, length);
		String8 mimeType;
		float confidence;
		if (SniffWVM(source, &mimeType, &confidence, NULL /* format */)) {
		return 1.0;
		}
		}

		if (getDefaultPlayerType() == STAGEFRIGHT_PLAYER) {
		char buf[20];
		lseek(fd, offset, SEEK_SET);
		read(fd, buf, sizeof(buf));
		lseek(fd, offset, SEEK_SET);

		uint32_t ident = ((uint32_t)buf);

		// Ogg vorbis?
		if (ident == 0x5367674f) // 'OggS'
		return 1.0;
		}

		return 0.0;
		}

		virtual float scoreFactory(const sp<IMediaPlayer>& /client/,
		const char* url,
		float /curScore/) {
		if (legacyDrm() && !strncasecmp("widevine://", url, 11)) {
		return 1.0;
		}
		return 0.0;
		}

		virtual sp<MediaPlayerBase> createPlayer(pid_t /* pid */) {
		ALOGV(" create StagefrightPlayer");
		return new StagefrightPlayer();
		}
		private:
		bool legacyDrm() {
		char value[PROPERTY_VALUE_MAX];
		if (property_get("persist.sys.media.legacy-drm", value, NULL)
		&& (!strcmp("1", value) \|\| !strcasecmp("true", value))) {
		return true;
		}
		return false;
		}
		};

		class NuPlayerFactory : public MediaPlayerFactory::IFactory {
		public:
		virtual float scoreFactory(const sp<IMediaPlayer>& /client/,
		@@ -310,7 +246,6 @@ void MediaPlayerFactory::registerBuiltinFactories() {
		if (sInitComplete)
		return;

		registerFactory_l(new StagefrightPlayerFactory(), STAGEFRIGHT_PLAYER);
		registerFactory_l(new NuPlayerFactory(), NU_PLAYER);
		registerFactory_l(new TestPlayerFactory(), TEST_PLAYER);

media/libmediaplayerservice/MediaPlayerService.cpp

+0 −2

Original line number	Diff line number	Diff line
		@@ -57,7 +57,6 @@
		#include <media/MemoryLeakTrackUtil.h>
		#include <media/stagefright/MediaCodecList.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/AudioPlayer.h>
		#include <media/stagefright/Utils.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/ALooperRoster.h>
		@@ -74,7 +73,6 @@
		#include "MediaPlayerFactory.h"

		#include "TestPlayerStub.h"
		#include "StagefrightPlayer.h"
		#include "nuplayer/NuPlayerDriver.h"

		#include <OMX.h>

media/libmediaplayerservice/StagefrightPlayer.cpp

deleted100644 → 0

+0 −230

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "StagefrightPlayer"
		#include <utils/Log.h>

		#include "StagefrightPlayer.h"

		#include "AwesomePlayer.h"

		#include <media/Metadata.h>
		#include <media/stagefright/MediaExtractor.h>

		namespace android {

		StagefrightPlayer::StagefrightPlayer()
		: mPlayer(new AwesomePlayer) {
		ALOGV("StagefrightPlayer");

		mPlayer->setListener(this);
		}

		StagefrightPlayer::~StagefrightPlayer() {
		ALOGV("~StagefrightPlayer");
		reset();

		delete mPlayer;
		mPlayer = NULL;
		}

		status_t StagefrightPlayer::initCheck() {
		ALOGV("initCheck");
		return OK;
		}

		status_t StagefrightPlayer::setUID(uid_t uid) {
		mPlayer->setUID(uid);

		return OK;
		}

		status_t StagefrightPlayer::setDataSource(
		const sp<IMediaHTTPService> &httpService,
		const char *url,
		const KeyedVector<String8, String8> *headers) {
		return mPlayer->setDataSource(httpService, url, headers);
		}

		// Warning: The filedescriptor passed into this method will only be valid until
		// the method returns, if you want to keep it, dup it!
		status_t StagefrightPlayer::setDataSource(int fd, int64_t offset, int64_t length) {
		ALOGV("setDataSource(%d, %lld, %lld)", fd, offset, length);
		return mPlayer->setDataSource(fd, offset, length);
		}

		status_t StagefrightPlayer::setDataSource(const sp<IStreamSource> &source) {
		return mPlayer->setDataSource(source);
		}

		status_t StagefrightPlayer::setVideoSurfaceTexture(
		const sp<IGraphicBufferProducer> &bufferProducer) {
		ALOGV("setVideoSurfaceTexture");

		return mPlayer->setSurfaceTexture(bufferProducer);
		}

		status_t StagefrightPlayer::prepare() {
		return mPlayer->prepare();
		}

		status_t StagefrightPlayer::prepareAsync() {
		return mPlayer->prepareAsync();
		}

		status_t StagefrightPlayer::start() {
		ALOGV("start");

		return mPlayer->play();
		}

		status_t StagefrightPlayer::stop() {
		ALOGV("stop");

		return pause(); // what's the difference?
		}

		status_t StagefrightPlayer::pause() {
		ALOGV("pause");

		return mPlayer->pause();
		}

		bool StagefrightPlayer::isPlaying() {
		ALOGV("isPlaying");
		return mPlayer->isPlaying();
		}

		status_t StagefrightPlayer::seekTo(int msec) {
		ALOGV("seekTo %.2f secs", msec / 1E3);

		status_t err = mPlayer->seekTo((int64_t)msec * 1000);

		return err;
		}

		status_t StagefrightPlayer::getCurrentPosition(int *msec) {
		ALOGV("getCurrentPosition");

		int64_t positionUs;
		status_t err = mPlayer->getPosition(&positionUs);

		if (err != OK) {
		return err;
		}

		*msec = (positionUs + 500) / 1000;

		return OK;
		}

		status_t StagefrightPlayer::getDuration(int *msec) {
		ALOGV("getDuration");

		int64_t durationUs;
		status_t err = mPlayer->getDuration(&durationUs);

		if (err != OK) {
		*msec = 0;
		return OK;
		}

		*msec = (durationUs + 500) / 1000;

		return OK;
		}

		status_t StagefrightPlayer::reset() {
		ALOGV("reset");

		mPlayer->reset();

		return OK;
		}

		status_t StagefrightPlayer::setLooping(int loop) {
		ALOGV("setLooping");

		return mPlayer->setLooping(loop);
		}

		player_type StagefrightPlayer::playerType() {
		ALOGV("playerType");
		return STAGEFRIGHT_PLAYER;
		}

		status_t StagefrightPlayer::invoke(const Parcel &request, Parcel *reply) {
		ALOGV("invoke()");
		return mPlayer->invoke(request, reply);
		}

		void StagefrightPlayer::setAudioSink(const sp<AudioSink> &audioSink) {
		MediaPlayerInterface::setAudioSink(audioSink);

		mPlayer->setAudioSink(audioSink);
		}

		status_t StagefrightPlayer::setParameter(int key, const Parcel &request) {
		ALOGV("setParameter(key=%d)", key);
		return mPlayer->setParameter(key, request);
		}

		status_t StagefrightPlayer::getParameter(int key, Parcel *reply) {
		ALOGV("getParameter");
		return mPlayer->getParameter(key, reply);
		}

		status_t StagefrightPlayer::setPlaybackSettings(const AudioPlaybackRate &rate) {
		return mPlayer->setPlaybackSettings(rate);
		}

		status_t StagefrightPlayer::getPlaybackSettings(AudioPlaybackRate rate / nonnull */) {
		return mPlayer->getPlaybackSettings(rate);
		}

		status_t StagefrightPlayer::getMetadata(
		const media::Metadata::Filter& /* ids /, Parcel records) {
		using media::Metadata;

		uint32_t flags = mPlayer->flags();

		Metadata metadata(records);

		metadata.appendBool(
		Metadata::kPauseAvailable,
		flags & MediaExtractor::CAN_PAUSE);

		metadata.appendBool(
		Metadata::kSeekBackwardAvailable,
		flags & MediaExtractor::CAN_SEEK_BACKWARD);

		metadata.appendBool(
		Metadata::kSeekForwardAvailable,
		flags & MediaExtractor::CAN_SEEK_FORWARD);

		metadata.appendBool(
		Metadata::kSeekAvailable,
		flags & MediaExtractor::CAN_SEEK);

		return OK;
		}

		status_t StagefrightPlayer::dump(int fd, const Vector<String16> &args) const {
		return mPlayer->dump(fd, args);
		}

		} // namespace android