Merge "Remove legacy PV stuff" (c7f26cb1) · Commits · e / os / android_frameworks_av

include/media/PVMediaRecorder.h

deleted100644 → 0

+0 −68

Original line number	Original line	Diff line number	Diff line
	/*
	**
	** Copyright 2008, 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.
	*/

	#ifndef ANDROID_PVMEDIARECORDER_H
	#define ANDROID_PVMEDIARECORDER_H

	#include <media/IMediaRecorderClient.h>
	#include <media/MediaRecorderBase.h>

	namespace android {

	class Surface;
	class ICamera;
	class AuthorDriverWrapper;

	class PVMediaRecorder : public MediaRecorderBase {
	public:
	PVMediaRecorder();
	virtual ~PVMediaRecorder();

	virtual status_t init();
	virtual status_t setAudioSource(audio_source as);
	virtual status_t setVideoSource(video_source vs);
	virtual status_t setOutputFormat(output_format of);
	virtual status_t setAudioEncoder(audio_encoder ae);
	virtual status_t setVideoEncoder(video_encoder ve);
	virtual status_t setVideoSize(int width, int height);
	virtual status_t setVideoFrameRate(int frames_per_second);
	virtual status_t setCamera(const sp<ICamera>& camera);
	virtual status_t setPreviewSurface(const sp<Surface>& surface);
	virtual status_t setOutputFile(const char *path);
	virtual status_t setOutputFile(int fd, int64_t offset, int64_t length);
	virtual status_t setParameters(const String8& params);
	virtual status_t setListener(const sp<IMediaRecorderClient>& listener);
	virtual status_t prepare();
	virtual status_t start();
	virtual status_t stop();
	virtual status_t close();
	virtual status_t reset();
	virtual status_t getMaxAmplitude(int *max);
	virtual status_t dump(int fd, const Vector<String16>& args) const;

	private:
	status_t doStop();

	AuthorDriverWrapper* mAuthorDriverWrapper;

	PVMediaRecorder(const PVMediaRecorder &);
	PVMediaRecorder &operator=(const PVMediaRecorder &);
	};

	}; // namespace android

	#endif // ANDROID_PVMEDIARECORDER_H

include/media/PVMetadataRetriever.h

deleted100644 → 0

+0 −51

Original line number	Original line	Diff line number	Diff line
	/*
	**
	** Copyright (C) 2008 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.
	*/

	#ifndef ANDROID_PVMETADATARETRIEVER_H
	#define ANDROID_PVMETADATARETRIEVER_H

	#include <utils/Errors.h>
	#include <media/MediaMetadataRetrieverInterface.h>
	#include <private/media/VideoFrame.h>

	namespace android {

	class MetadataDriver;

	class PVMetadataRetriever : public MediaMetadataRetrieverInterface
	{
	public:
	PVMetadataRetriever();
	virtual ~PVMetadataRetriever();

	virtual status_t setDataSource(const char *url);
	virtual status_t setDataSource(int fd, int64_t offset, int64_t length);
	virtual status_t setMode(int mode);
	virtual status_t getMode(int* mode) const;
	virtual VideoFrame* captureFrame();
	virtual MediaAlbumArt* extractAlbumArt();
	virtual const char* extractMetadata(int keyCode);

	private:
	mutable Mutex mLock;
	MetadataDriver* mMetadataDriver;
	char* mDataSourcePath;
	};

	}; // namespace android

	#endif // ANDROID_PVMETADATARETRIEVER_H

include/media/PVPlayer.h

deleted100644 → 0

+0 −91

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2008 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.
	*/

	#ifndef ANDROID_PVPLAYER_H
	#define ANDROID_PVPLAYER_H

	#include <utils/Errors.h>
	#include <media/MediaPlayerInterface.h>
	#include <media/Metadata.h>

	#define MAX_OPENCORE_INSTANCES 25

	#ifdef MAX_OPENCORE_INSTANCES
	#include <cutils/atomic.h>
	#endif

	class PlayerDriver;

	namespace android {

	class PVPlayer : public MediaPlayerInterface
	{
	public:
	PVPlayer();
	virtual ~PVPlayer();

	virtual status_t initCheck();

	virtual status_t setDataSource(
	const char url, const KeyedVector<String8, String8> headers);

	virtual status_t setDataSource(int fd, int64_t offset, int64_t length);
	virtual status_t setVideoISurface(const sp<ISurface>& surface);
	virtual status_t setVideoSurface(const sp<Surface>& surface);
	virtual status_t prepare();
	virtual status_t prepareAsync();
	virtual status_t start();
	virtual status_t stop();
	virtual status_t pause();
	virtual bool isPlaying();
	virtual status_t seekTo(int msec);
	virtual status_t getCurrentPosition(int *msec);
	virtual status_t getDuration(int *msec);
	virtual status_t reset();
	virtual status_t setLooping(int loop);
	virtual player_type playerType() { return PV_PLAYER; }
	virtual status_t invoke(const Parcel& request, Parcel *reply);
	virtual status_t getMetadata(
	const SortedVector<media::Metadata::Type>& ids,
	Parcel *records);

	// make available to PlayerDriver
	void sendEvent(int msg, int ext1=0, int ext2=0) { MediaPlayerBase::sendEvent(msg, ext1, ext2); }

	private:
	static void do_nothing(status_t s, void *cookie, bool cancelled) { }
	static void run_init(status_t s, void *cookie, bool cancelled);
	static void run_set_video_surface(status_t s, void *cookie, bool cancelled);
	static void run_set_audio_output(status_t s, void *cookie, bool cancelled);
	static void run_prepare(status_t s, void *cookie, bool cancelled);
	static void check_for_live_streaming(status_t s, void *cookie, bool cancelled);

	PlayerDriver* mPlayerDriver;
	char * mDataSourcePath;
	bool mIsDataSourceSet;
	sp<ISurface> mSurface;
	int mSharedFd;
	status_t mInit;
	int mDuration;

	#ifdef MAX_OPENCORE_INSTANCES
	static volatile int32_t sNumInstances;
	#endif
	};

	}; // namespace android

	#endif // ANDROID_PVPLAYER_H

media/libmediaplayerservice/Android.mk

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -38,14 +38,6 @@ LOCAL_SHARED_LIBRARIES := \
	LOCAL_STATIC_LIBRARIES := \		LOCAL_STATIC_LIBRARIES := \
	libstagefright_rtsp		libstagefright_rtsp

	ifneq ($(BUILD_WITHOUT_PV),true)
	LOCAL_SHARED_LIBRARIES += \
	libopencore_player \
	libopencore_author
	else
	LOCAL_CFLAGS += -DNO_OPENCORE
	endif

	ifneq ($(TARGET_SIMULATOR),true)		ifneq ($(TARGET_SIMULATOR),true)
	LOCAL_SHARED_LIBRARIES += libdl		LOCAL_SHARED_LIBRARIES += libdl
	endif		endif

media/libmediaplayerservice/MediaPlayerService.cpp

+3 −30

Original line number	Original line	Diff line number	Diff line
	@@ -56,7 +56,6 @@
	#include "MetadataRetrieverClient.h"		#include "MetadataRetrieverClient.h"

	#include "MidiFile.h"		#include "MidiFile.h"
	#include <media/PVPlayer.h>
	#include "TestPlayerStub.h"		#include "TestPlayerStub.h"
	#include "StagefrightPlayer.h"		#include "StagefrightPlayer.h"

	@@ -196,11 +195,6 @@ extmap FILE_EXTS [] = {
	{".rtttl", SONIVOX_PLAYER},		{".rtttl", SONIVOX_PLAYER},
	{".rtx", SONIVOX_PLAYER},		{".rtx", SONIVOX_PLAYER},
	{".ota", SONIVOX_PLAYER},		{".ota", SONIVOX_PLAYER},
	#ifndef NO_OPENCORE
	{".wma", PV_PLAYER},
	{".wmv", PV_PLAYER},
	{".asf", PV_PLAYER},
	#endif
	};		};

	// TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround		// TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround
	@@ -691,14 +685,6 @@ player_type getPlayerType(int fd, int64_t offset, int64_t length)
	if (ident == 0x5367674f) // 'OggS'		if (ident == 0x5367674f) // 'OggS'
	return STAGEFRIGHT_PLAYER;		return STAGEFRIGHT_PLAYER;

	#ifndef NO_OPENCORE
	if (ident == 0x75b22630) {
	// The magic number for .asf files, i.e. wmv and wma content.
	// These are not currently supported through stagefright.
	return PV_PLAYER;
	}
	#endif

	// Some kind of MIDI?		// Some kind of MIDI?
	EAS_DATA_HANDLE easdata;		EAS_DATA_HANDLE easdata;
	if (EAS_Init(&easdata) == EAS_SUCCESS) {		if (EAS_Init(&easdata) == EAS_SUCCESS) {
	@@ -737,16 +723,6 @@ player_type getPlayerType(const char* url)
	}		}
	}		}

	if (!strncasecmp(url, "rtsp://", 7)) {
	char value[PROPERTY_VALUE_MAX];
	if (property_get("media.stagefright.enable-rtsp", value, NULL)
	&& (strcmp(value, "1") && strcasecmp(value, "true"))) {
	// For now, we're going to use PV for rtsp-based playback
	// by default until we can clear up a few more issues.
	return PV_PLAYER;
	}
	}

	return getDefaultPlayerType();		return getDefaultPlayerType();
	}		}

	@@ -755,12 +731,6 @@ static sp<MediaPlayerBase> createPlayer(player_type playerType, void* cookie,
	{		{
	sp<MediaPlayerBase> p;		sp<MediaPlayerBase> p;
	switch (playerType) {		switch (playerType) {
	#ifndef NO_OPENCORE
	case PV_PLAYER:
	LOGV(" create PVPlayer");
	p = new PVPlayer();
	break;
	#endif
	case SONIVOX_PLAYER:		case SONIVOX_PLAYER:
	LOGV(" create MidiFile");		LOGV(" create MidiFile");
	p = new MidiFile();		p = new MidiFile();
	@@ -773,6 +743,9 @@ static sp<MediaPlayerBase> createPlayer(player_type playerType, void* cookie,
	LOGV("Create Test Player stub");		LOGV("Create Test Player stub");
	p = new TestPlayerStub();		p = new TestPlayerStub();
	break;		break;
			default:
			LOGE("Unknown player type: %d", playerType);
			return NULL;
	}		}
	if (p != NULL) {		if (p != NULL) {
	if (p->initCheck() == NO_ERROR) {		if (p->initCheck() == NO_ERROR) {