Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Remove all traces of legacy renderer support in stagefright."

Browse Source
This commit is contained in:
Andreas Huber
2010-11-16 13:59:02 -08:00
committed by Android (Google) Code Review
parent c5f99f39c6 c23dabfb20
commit f4726a22c8
21 changed files with 43 additions and 559 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/media/IMediaPlayer.h
View File

@@ -34,7 +34,6 @@ public:
virtual void disconnect() = 0;
virtual status_t setVideoISurface(const sp<ISurface>& surface) = 0;
virtual status_t setVideoSurface(const sp<Surface>& surface) = 0;
virtual status_t prepareAsync() = 0;
virtual status_t start() = 0;

38
include/media/IOMX.h
View File

@@ -120,30 +120,6 @@ public:
node_id node,
const char *parameter_name,
OMX_INDEXTYPE *index) = 0;
virtual sp<IOMXRenderer> createRenderer(
const sp<ISurface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight) = 0;
// Note: These methods are _not_ virtual, it exists as a wrapper around
// the virtual "createRenderer" method above facilitating extraction
// of the ISurface from a regular Surface or a java Surface object.
sp<IOMXRenderer> createRenderer(
const sp<Surface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight);
sp<IOMXRenderer> createRendererFromJavaSurface(
JNIEnv *env, jobject javaSurface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight);
};
struct omx_message {
@@ -190,13 +166,6 @@ public:
virtual void onMessage(const omx_message &msg) = 0;
};
class IOMXRenderer : public IInterface {
public:
DECLARE_META_INTERFACE(OMXRenderer);
virtual void render(IOMX::buffer_id buffer) = 0;
};
////////////////////////////////////////////////////////////////////////////////
class BnOMX : public BnInterface<IOMX> {
@@ -213,13 +182,6 @@ public:
uint32_t flags = 0);
};
class BnOMXRenderer : public BnInterface<IOMXRenderer> {
public:
virtual status_t onTransact(
uint32_t code, const Parcel &data, Parcel *reply,
uint32_t flags = 0);
};
} // namespace android
#endif // ANDROID_IOMX_H_

1
include/media/MediaPlayerInterface.h
View File

@@ -106,7 +106,6 @@ public:
const KeyedVector<String8, String8> *headers = NULL) = 0;
virtual status_t setDataSource(int fd, int64_t offset, int64_t length) = 0;
virtual status_t setVideoISurface(const sp<ISurface>& surface) = 0;
virtual status_t setVideoSurface(const sp<Surface>& surface) = 0;
virtual status_t prepare() = 0;
virtual status_t prepareAsync() = 0;

9
include/media/stagefright/HardwareAPI.h
View File

@@ -19,8 +19,6 @@
#define HARDWARE_API_H_
#include <media/stagefright/OMXPluginBase.h>
#include <media/stagefright/VideoRenderer.h>
#include <surfaceflinger/ISurface.h>
#include <ui/android_native_buffer.h>
#include <utils/RefBase.h>
@@ -91,13 +89,6 @@ struct UseAndroidNativeBufferParams {
} // namespace android
extern android::VideoRenderer *createRenderer(
const android::sp<android::ISurface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t displayWidth, size_t displayHeight,
size_t decodedWidth, size_t decodedHeight);
extern android::OMXPluginBase *createOMXPlugin();
#endif // HARDWARE_API_H_

41
include/media/stagefright/VideoRenderer.h
View File

@@ -1,41 +0,0 @@
/*
* 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.
*/
#ifndef VIDEO_RENDERER_H_
#define VIDEO_RENDERER_H_
#include <sys/types.h>
namespace android {
class VideoRenderer {
public:
virtual ~VideoRenderer() {}
virtual void render(
const void *data, size_t size, void *platformPrivate) = 0;
protected:
VideoRenderer() {}
VideoRenderer(const VideoRenderer &);
VideoRenderer &operator=(const VideoRenderer &);
};
} // namespace android
#endif // VIDEO_RENDERER_H_

16
media/libmedia/IMediaPlayer.cpp
View File

@@ -29,7 +29,6 @@ namespace android {
enum {
DISCONNECT = IBinder::FIRST_CALL_TRANSACTION,
SET_VIDEO_SURFACE,
SET_VIDEO_ISURFACE,
PREPARE_ASYNC,
START,
STOP,
@@ -65,15 +64,6 @@ public:
remote()->transact(DISCONNECT, data, &reply);
}
status_t setVideoISurface(const sp<ISurface>& surface)
{
Parcel data, reply;
data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
data.writeStrongBinder(surface->asBinder());
remote()->transact(SET_VIDEO_ISURFACE, data, &reply);
return reply.readInt32();
}
status_t setVideoSurface(const sp<Surface>& surface)
{
Parcel data, reply;
@@ -245,12 +235,6 @@ status_t BnMediaPlayer::onTransact(
disconnect();
return NO_ERROR;
} break;
case SET_VIDEO_ISURFACE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
reply->writeInt32(setVideoISurface(surface));
return NO_ERROR;
} break;
case SET_VIDEO_SURFACE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<Surface> surface = Surface::readFromParcel(data);

128
media/libmedia/IOMX.cpp
View File

@@ -31,48 +31,9 @@ enum {
FILL_BUFFER,
EMPTY_BUFFER,
GET_EXTENSION_INDEX,
CREATE_RENDERER,
OBSERVER_ON_MSG,
RENDERER_RENDER,
};
sp<IOMXRenderer> IOMX::createRenderer(
const sp<Surface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight) {
return createRenderer(
surface->getISurface(),
componentName, colorFormat, encodedWidth, encodedHeight,
displayWidth, displayHeight);
}
sp<IOMXRenderer> IOMX::createRendererFromJavaSurface(
JNIEnv *env, jobject javaSurface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight) {
jclass surfaceClass = env->FindClass("android/view/Surface");
if (surfaceClass == NULL) {
LOGE("Can't find android/view/Surface");
return NULL;
}
jfieldID surfaceID = env->GetFieldID(surfaceClass, ANDROID_VIEW_SURFACE_JNI_ID, "I");
if (surfaceID == NULL) {
LOGE("Can't find Surface.mSurface");
return NULL;
}
sp<Surface> surface = (Surface *)env->GetIntField(javaSurface, surfaceID);
return createRenderer(
surface, componentName, colorFormat, encodedWidth,
encodedHeight, displayWidth, displayHeight);
}
class BpOMX : public BpInterface<IOMX> {
public:
BpOMX(const sp<IBinder> &impl)
@@ -395,28 +356,6 @@ public:
return err;
}
virtual sp<IOMXRenderer> createRenderer(
const sp<ISurface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight) {
Parcel data, reply;
data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
data.writeStrongBinder(surface->asBinder());
data.writeCString(componentName);
data.writeInt32(colorFormat);
data.writeInt32(encodedWidth);
data.writeInt32(encodedHeight);
data.writeInt32(displayWidth);
data.writeInt32(displayHeight);
remote()->transact(CREATE_RENDERER, data, &reply);
return interface_cast<IOMXRenderer>(reply.readStrongBinder());
}
};
IMPLEMENT_META_INTERFACE(OMX, "android.hardware.IOMX");
@@ -767,33 +706,6 @@ status_t BnOMX::onTransact(
return OK;
}
case CREATE_RENDERER:
{
CHECK_INTERFACE(IOMX, data, reply);
sp<ISurface> isurface =
interface_cast<ISurface>(data.readStrongBinder());
const char *componentName = data.readCString();
OMX_COLOR_FORMATTYPE colorFormat =
static_cast<OMX_COLOR_FORMATTYPE>(data.readInt32());
size_t encodedWidth = (size_t)data.readInt32();
size_t encodedHeight = (size_t)data.readInt32();
size_t displayWidth = (size_t)data.readInt32();
size_t displayHeight = (size_t)data.readInt32();
sp<IOMXRenderer> renderer =
createRenderer(isurface, componentName, colorFormat,
encodedWidth, encodedHeight,
displayWidth, displayHeight);
reply->writeStrongBinder(renderer->asBinder());
return OK;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
@@ -839,44 +751,4 @@ status_t BnOMXObserver::onTransact(
}
}
////////////////////////////////////////////////////////////////////////////////
class BpOMXRenderer : public BpInterface<IOMXRenderer> {
public:
BpOMXRenderer(const sp<IBinder> &impl)
: BpInterface<IOMXRenderer>(impl) {
}
virtual void render(IOMX::buffer_id buffer) {
Parcel data, reply;
data.writeInterfaceToken(IOMXRenderer::getInterfaceDescriptor());
data.writeIntPtr((intptr_t)buffer);
// NOTE: Do NOT make this a ONE_WAY call, it must be synchronous
// so that the caller knows when to recycle the buffer.
remote()->transact(RENDERER_RENDER, data, &reply);
}
};
IMPLEMENT_META_INTERFACE(OMXRenderer, "android.hardware.IOMXRenderer");
status_t BnOMXRenderer::onTransact(
uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
switch (code) {
case RENDERER_RENDER:
{
CHECK_INTERFACE(IOMXRenderer, data, reply);
IOMX::buffer_id buffer = (void*)data.readIntPtr();
render(buffer);
return NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
} // namespace android

7
media/libmedia/mediaplayer.cpp
View File

@@ -198,13 +198,6 @@ status_t MediaPlayer::setVideoSurface(const sp<Surface>& surface)
Mutex::Autolock _l(mLock);
if (mPlayer == 0) return NO_INIT;
status_t err = mPlayer->setVideoISurface(
surface == NULL ? NULL : surface->getISurface());
if (err != OK) {
return err;
}
return mPlayer->setVideoSurface(surface);
}

8
media/libmediaplayerservice/MediaPlayerService.cpp
View File

@@ -864,14 +864,6 @@ status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64
return mStatus;
}
status_t MediaPlayerService::Client::setVideoISurface(const sp<ISurface>& surface)
{
LOGV("[%d] setVideoISurface(%p)", mConnId, surface.get());
sp<MediaPlayerBase> p = getPlayer();
if (p == 0) return UNKNOWN_ERROR;
return p->setVideoISurface(surface);
}
status_t MediaPlayerService::Client::setVideoSurface(const sp<Surface>& surface)
{
LOGV("[%d] setVideoSurface(%p)", mConnId, surface.get());

1
media/libmediaplayerservice/MediaPlayerService.h
View File

@@ -206,7 +206,6 @@ private:
// IMediaPlayer interface
virtual void disconnect();
virtual status_t setVideoISurface(const sp<ISurface>& surface);
virtual status_t setVideoSurface(const sp<Surface>& surface);
virtual status_t prepareAsync();
virtual status_t start();

1
media/libmediaplayerservice/MidiFile.h
View File

@@ -35,7 +35,6 @@ public:
const char* path, 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) { return UNKNOWN_ERROR; }
virtual status_t setVideoSurface(const sp<Surface>& surface) { return UNKNOWN_ERROR; }
virtual status_t prepare();
virtual status_t prepareAsync();

7
media/libmediaplayerservice/StagefrightPlayer.cpp
View File

@@ -44,13 +44,6 @@ status_t StagefrightPlayer::setDataSource(int fd, int64_t offset, int64_t length
return mPlayer->setDataSource(dup(fd), offset, length);
}
status_t StagefrightPlayer::setVideoISurface(const sp<ISurface> &surface) {
LOGV("setVideoISurface");
mPlayer->setISurface(surface);
return OK;
}
status_t StagefrightPlayer::setVideoSurface(const sp<Surface> &surface) {
LOGV("setVideoSurface");

1
media/libmediaplayerservice/StagefrightPlayer.h
View File

@@ -35,7 +35,6 @@ public:
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();

3
media/libmediaplayerservice/TestPlayerStub.h
View File

@@ -75,9 +75,6 @@ class TestPlayerStub : public MediaPlayerInterface {
// All the methods below wrap the mPlayer instance.
virtual status_t setVideoISurface(const android::sp<android::ISurface>& s) {
return mPlayer->setVideoISurface(s);
}
virtual status_t setVideoSurface(const android::sp<android::Surface>& s) {
return mPlayer->setVideoSurface(s);
}

169
media/libstagefright/AwesomePlayer.cpp
View File

@@ -79,39 +79,16 @@ private:
AwesomeEvent &operator=(const AwesomeEvent &);
};
struct AwesomeRemoteRenderer : public AwesomeRenderer {
AwesomeRemoteRenderer(const sp<IOMXRenderer> &target)
: mTarget(target) {
}
virtual void render(MediaBuffer *buffer) {
void *id;
if (buffer->meta_data()->findPointer(kKeyBufferID, &id)) {
mTarget->render((IOMX::buffer_id)id);
}
}
private:
sp<IOMXRenderer> mTarget;
AwesomeRemoteRenderer(const AwesomeRemoteRenderer &);
AwesomeRemoteRenderer &operator=(const AwesomeRemoteRenderer &);
};
struct AwesomeLocalRenderer : public AwesomeRenderer {
AwesomeLocalRenderer(
bool previewOnly,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
const sp<ISurface> &isurface,
const sp<Surface> &surface,
size_t displayWidth, size_t displayHeight,
size_t decodedWidth, size_t decodedHeight)
: mTarget(NULL),
mLibHandle(NULL) {
init(previewOnly, componentName,
colorFormat, isurface, surface, displayWidth,
displayHeight, decodedWidth, decodedHeight);
: mTarget(NULL) {
init(colorFormat, surface,
displayWidth, displayHeight,
decodedWidth, decodedHeight);
}
virtual void render(MediaBuffer *buffer) {
@@ -127,22 +104,13 @@ protected:
virtual ~AwesomeLocalRenderer() {
delete mTarget;
mTarget = NULL;
if (mLibHandle) {
dlclose(mLibHandle);
mLibHandle = NULL;
}
}
private:
VideoRenderer *mTarget;
void *mLibHandle;
SoftwareRenderer *mTarget;
void init(
bool previewOnly,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
const sp<ISurface> &isurface,
const sp<Surface> &surface,
size_t displayWidth, size_t displayHeight,
size_t decodedWidth, size_t decodedHeight);
@@ -152,48 +120,13 @@ private:
};
void AwesomeLocalRenderer::init(
bool previewOnly,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
const sp<ISurface> &isurface,
const sp<Surface> &surface,
size_t displayWidth, size_t displayHeight,
size_t decodedWidth, size_t decodedHeight) {
if (!previewOnly) {
// We will stick to the vanilla software-color-converting renderer
// for "previewOnly" mode, to avoid unneccessarily switching overlays
// more often than necessary.
mLibHandle = dlopen("libstagefrighthw.so", RTLD_NOW);
if (mLibHandle) {
typedef VideoRenderer *(*CreateRendererFunc)(
const sp<ISurface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t displayWidth, size_t displayHeight,
size_t decodedWidth, size_t decodedHeight);
CreateRendererFunc func =
(CreateRendererFunc)dlsym(
mLibHandle,
"_Z14createRendererRKN7android2spINS_8ISurfaceEEEPKc20"
"OMX_COLOR_FORMATTYPEjjjj");
if (func) {
mTarget =
(*func)(isurface, componentName, colorFormat,
displayWidth, displayHeight,
decodedWidth, decodedHeight);
}
}
}
if (mTarget == NULL) {
mTarget = new SoftwareRenderer(
colorFormat, surface, displayWidth, displayHeight,
decodedWidth, decodedHeight);
}
mTarget = new SoftwareRenderer(
colorFormat, surface, displayWidth, displayHeight,
decodedWidth, decodedHeight);
}
struct AwesomeNativeWindowRenderer : public AwesomeRenderer {
@@ -867,54 +800,41 @@ void AwesomePlayer::notifyVideoSize_l() {
}
void AwesomePlayer::initRenderer_l() {
if (mSurface != NULL || mISurface != NULL) {
sp<MetaData> meta = mVideoSource->getFormat();
if (mSurface == NULL) {
return;
}
int32_t format;
const char *component;
int32_t decodedWidth, decodedHeight;
CHECK(meta->findInt32(kKeyColorFormat, &format));
CHECK(meta->findCString(kKeyDecoderComponent, &component));
CHECK(meta->findInt32(kKeyWidth, &decodedWidth));
CHECK(meta->findInt32(kKeyHeight, &decodedHeight));
sp<MetaData> meta = mVideoSource->getFormat();
mVideoRenderer.clear();
int32_t format;
const char *component;
int32_t decodedWidth, decodedHeight;
CHECK(meta->findInt32(kKeyColorFormat, &format));
CHECK(meta->findCString(kKeyDecoderComponent, &component));
CHECK(meta->findInt32(kKeyWidth, &decodedWidth));
CHECK(meta->findInt32(kKeyHeight, &decodedHeight));
// Must ensure that mVideoRenderer's destructor is actually executed
// before creating a new one.
IPCThreadState::self()->flushCommands();
mVideoRenderer.clear();
if (mSurface != NULL) {
if (USE_SURFACE_ALLOC && strncmp(component, "OMX.", 4) == 0) {
// Hardware decoders avoid the CPU color conversion by decoding
// directly to ANativeBuffers, so we must use a renderer that
// just pushes those buffers to the ANativeWindow.
mVideoRenderer = new AwesomeNativeWindowRenderer(mSurface);
} else {
// Other decoders are instantiated locally and as a consequence
// allocate their buffers in local address space. This renderer
// then performs a color conversion and copy to get the data
// into the ANativeBuffer.
mVideoRenderer = new AwesomeLocalRenderer(
false, // previewOnly
component,
(OMX_COLOR_FORMATTYPE)format,
mISurface,
mSurface,
mVideoWidth, mVideoHeight,
decodedWidth, decodedHeight);
}
} else {
// Our OMX codecs allocate buffers on the media_server side
// therefore they require a remote IOMXRenderer that knows how
// to display them.
mVideoRenderer = new AwesomeRemoteRenderer(
mClient.interface()->createRenderer(
mISurface, component,
(OMX_COLOR_FORMATTYPE)format,
decodedWidth, decodedHeight,
mVideoWidth, mVideoHeight));
}
// Must ensure that mVideoRenderer's destructor is actually executed
// before creating a new one.
IPCThreadState::self()->flushCommands();
if (USE_SURFACE_ALLOC && strncmp(component, "OMX.", 4) == 0) {
// Hardware decoders avoid the CPU color conversion by decoding
// directly to ANativeBuffers, so we must use a renderer that
// just pushes those buffers to the ANativeWindow.
mVideoRenderer = new AwesomeNativeWindowRenderer(mSurface);
} else {
// Other decoders are instantiated locally and as a consequence
// allocate their buffers in local address space. This renderer
// then performs a color conversion and copy to get the data
// into the ANativeBuffer.
mVideoRenderer = new AwesomeLocalRenderer(
(OMX_COLOR_FORMATTYPE)format,
mSurface,
mVideoWidth, mVideoHeight,
decodedWidth, decodedHeight);
}
}
@@ -958,12 +878,6 @@ bool AwesomePlayer::isPlaying() const {
return (mFlags & PLAYING) || (mFlags & CACHE_UNDERRUN);
}
void AwesomePlayer::setISurface(const sp<ISurface> &isurface) {
Mutex::Autolock autoLock(mLock);
mISurface = isurface;
}
void AwesomePlayer::setSurface(const sp<Surface> &surface) {
Mutex::Autolock autoLock(mLock);
@@ -1897,13 +1811,10 @@ status_t AwesomePlayer::resume() {
mFlags = state->mFlags & (AUTO_LOOPING | LOOPING | AT_EOS);
if (state->mLastVideoFrame && (mSurface != NULL || mISurface != NULL)) {
if (state->mLastVideoFrame && mSurface != NULL) {
mVideoRenderer =
new AwesomeLocalRenderer(
true, // previewOnly
"",
(OMX_COLOR_FORMATTYPE)state->mColorFormat,
mISurface,
mSurface,
state->mVideoWidth,
state->mVideoHeight,

2
media/libstagefright/include/AwesomePlayer.h
View File

@@ -79,7 +79,6 @@ struct AwesomePlayer {
bool isPlaying() const;
void setISurface(const sp<ISurface> &isurface);
void setSurface(const sp<Surface> &surface);
void setAudioSink(const sp<MediaPlayerBase::AudioSink> &audioSink);
status_t setLooping(bool shouldLoop);
@@ -130,7 +129,6 @@ private:
bool mQueueStarted;
wp<MediaPlayerBase> mListener;
sp<ISurface> mISurface;
sp<Surface> mSurface;
sp<MediaPlayerBase::AudioSink> mAudioSink;

7
media/libstagefright/include/OMX.h
View File

@@ -97,13 +97,6 @@ public:
const char *parameter_name,
OMX_INDEXTYPE *index);
virtual sp<IOMXRenderer> createRenderer(
const sp<ISurface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight);
virtual void binderDied(const wp<IBinder> &the_late_who);
OMX_ERRORTYPE OnEvent(

8
media/libstagefright/include/SoftwareRenderer.h
View File

@@ -19,15 +19,13 @@
#define SOFTWARE_RENDERER_H_
#include <media/stagefright/ColorConverter.h>
#include <media/stagefright/VideoRenderer.h>
#include <utils/RefBase.h>
namespace android {
class Surface;
class MemoryHeapBase;
class SoftwareRenderer : public VideoRenderer {
class SoftwareRenderer {
public:
SoftwareRenderer(
OMX_COLOR_FORMATTYPE colorFormat,
@@ -35,9 +33,9 @@ public:
size_t displayWidth, size_t displayHeight,
size_t decodedWidth, size_t decodedHeight);
virtual ~SoftwareRenderer();
~SoftwareRenderer();
virtual void render(
void render(
const void *data, size_t size, void *platformPrivate);
private:

109
media/libstagefright/omx/OMX.cpp
View File

@@ -24,14 +24,11 @@
#include <sys/resource.h>
#include "../include/OMX.h"
#include "OMXRenderer.h"
#include "../include/OMXNodeInstance.h"
#include "../include/SoftwareRenderer.h"
#include <binder/IMemory.h>
#include <media/stagefright/MediaDebug.h>
#include <media/stagefright/VideoRenderer.h>
#include <utils/threads.h>
#include "OMXMaster.h"
@@ -442,110 +439,4 @@ void OMX::invalidateNodeID_l(node_id node) {
mNodeIDToInstance.removeItem(node);
}
////////////////////////////////////////////////////////////////////////////////
struct SharedVideoRenderer : public VideoRenderer {
SharedVideoRenderer(void *libHandle, VideoRenderer *obj)
: mLibHandle(libHandle),
mObj(obj) {
}
virtual ~SharedVideoRenderer() {
delete mObj;
mObj = NULL;
dlclose(mLibHandle);
mLibHandle = NULL;
}
virtual void render(
const void *data, size_t size, void *platformPrivate) {
return mObj->render(data, size, platformPrivate);
}
private:
void *mLibHandle;
VideoRenderer *mObj;
SharedVideoRenderer(const SharedVideoRenderer &);
SharedVideoRenderer &operator=(const SharedVideoRenderer &);
};
sp<IOMXRenderer> OMX::createRenderer(
const sp<ISurface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight) {
Mutex::Autolock autoLock(mLock);
VideoRenderer *impl = NULL;
void *libHandle = dlopen("libstagefrighthw.so", RTLD_NOW);
if (libHandle) {
typedef VideoRenderer *(*CreateRendererFunc)(
const sp<ISurface> &surface,
const char *componentName,
OMX_COLOR_FORMATTYPE colorFormat,
size_t displayWidth, size_t displayHeight,
size_t decodedWidth, size_t decodedHeight);
CreateRendererFunc func =
(CreateRendererFunc)dlsym(
libHandle,
"_Z14createRendererRKN7android2spINS_8ISurfaceEEEPKc20"
"OMX_COLOR_FORMATTYPEjjjj");
if (func) {
impl = (*func)(surface, componentName, colorFormat,
displayWidth, displayHeight, encodedWidth, encodedHeight);
if (impl) {
impl = new SharedVideoRenderer(libHandle, impl);
libHandle = NULL;
}
}
if (libHandle) {
dlclose(libHandle);
libHandle = NULL;
}
}
if (!impl) {
#if 0
LOGW("Using software renderer.");
impl = new SoftwareRenderer(
colorFormat,
surface,
displayWidth, displayHeight,
encodedWidth, encodedHeight);
#else
CHECK(!"Should not be here.");
return NULL;
#endif
}
return new OMXRenderer(impl);
}
OMXRenderer::OMXRenderer(VideoRenderer *impl)
: mImpl(impl) {
}
OMXRenderer::~OMXRenderer() {
delete mImpl;
mImpl = NULL;
}
void OMXRenderer::render(IOMX::buffer_id buffer) {
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
mImpl->render(
header->pBuffer + header->nOffset,
header->nFilledLen,
header->pPlatformPrivate);
}
} // namespace android

44
media/libstagefright/omx/OMXRenderer.h
View File

@@ -1,44 +0,0 @@
/*
* 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.
*/
#ifndef OMX_RENDERER_H_
#define OMX_RENDERER_H_
#include <media/IOMX.h>
namespace android {
class VideoRenderer;
class OMXRenderer : public BnOMXRenderer {
public:
// Assumes ownership of "impl".
OMXRenderer(VideoRenderer *impl);
virtual ~OMXRenderer();
virtual void render(IOMX::buffer_id buffer);
private:
VideoRenderer *mImpl;
OMXRenderer(const OMXRenderer &);
OMXRenderer &operator=(const OMXRenderer &);
};
} // namespace android
#endif // OMX_RENDERER_H_

1
media/tests/players/invoke_mock_media_player.cpp
View File

@@ -68,7 +68,6 @@ class Player: public MediaPlayerBase
}
virtual status_t setDataSource(int fd, int64_t offset, int64_t length) {return OK;}
virtual status_t setVideoISurface(const sp<ISurface>& surface) {return OK;}
virtual status_t setVideoSurface(const sp<Surface>& surface) {return OK;}
virtual status_t prepare() {return OK;}
virtual status_t prepareAsync() {return OK;}