blob: d03601fd1d10fc2ebcc837f8da4027c9be2b06a5 [file] [log] [blame]
/*
* Copyright (C) 2010 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 "NuPlayerDriver"
#include <utils/Log.h>
#include "NuPlayerDriver.h"
#include "NuPlayer.h"
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/ALooper.h>
namespace android {
NuPlayerDriver::NuPlayerDriver()
: mResetInProgress(false),
mDurationUs(-1),
mPositionUs(-1),
mNumFramesTotal(0),
mNumFramesDropped(0),
mLooper(new ALooper),
mState(UNINITIALIZED),
mAtEOS(false),
mStartupSeekTimeUs(-1) {
mLooper->setName("NuPlayerDriver Looper");
mLooper->start(
false, /* runOnCallingThread */
true, /* canCallJava */
PRIORITY_AUDIO);
mPlayer = new NuPlayer;
mLooper->registerHandler(mPlayer);
mPlayer->setDriver(this);
}
NuPlayerDriver::~NuPlayerDriver() {
mLooper->stop();
}
status_t NuPlayerDriver::initCheck() {
return OK;
}
status_t NuPlayerDriver::setUID(uid_t uid) {
mPlayer->setUID(uid);
return OK;
}
status_t NuPlayerDriver::setDataSource(
const char *url, const KeyedVector<String8, String8> *headers) {
CHECK_EQ((int)mState, (int)UNINITIALIZED);
mPlayer->setDataSource(url, headers);
mState = STOPPED;
return OK;
}
status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
CHECK_EQ((int)mState, (int)UNINITIALIZED);
mPlayer->setDataSource(fd, offset, length);
mState = STOPPED;
return OK;
}
status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
CHECK_EQ((int)mState, (int)UNINITIALIZED);
mPlayer->setDataSource(source);
mState = STOPPED;
return OK;
}
status_t NuPlayerDriver::setVideoSurfaceTexture(
const sp<ISurfaceTexture> &surfaceTexture) {
mPlayer->setVideoSurfaceTexture(surfaceTexture);
return OK;
}
status_t NuPlayerDriver::prepare() {
sendEvent(MEDIA_SET_VIDEO_SIZE, 0, 0);
return OK;
}
status_t NuPlayerDriver::prepareAsync() {
status_t err = prepare();
notifyListener(MEDIA_PREPARED);
return err;
}
status_t NuPlayerDriver::start() {
switch (mState) {
case UNINITIALIZED:
return INVALID_OPERATION;
case STOPPED:
{
mAtEOS = false;
mPlayer->start();
if (mStartupSeekTimeUs >= 0) {
if (mStartupSeekTimeUs == 0) {
notifySeekComplete();
} else {
mPlayer->seekToAsync(mStartupSeekTimeUs);
}
mStartupSeekTimeUs = -1;
}
break;
}
case PLAYING:
return OK;
default:
{
CHECK_EQ((int)mState, (int)PAUSED);
mPlayer->resume();
break;
}
}
mState = PLAYING;
return OK;
}
status_t NuPlayerDriver::stop() {
return pause();
}
status_t NuPlayerDriver::pause() {
switch (mState) {
case UNINITIALIZED:
return INVALID_OPERATION;
case STOPPED:
return OK;
case PLAYING:
mPlayer->pause();
break;
default:
{
CHECK_EQ((int)mState, (int)PAUSED);
return OK;
}
}
mState = PAUSED;
return OK;
}
bool NuPlayerDriver::isPlaying() {
return mState == PLAYING && !mAtEOS;
}
status_t NuPlayerDriver::seekTo(int msec) {
int64_t seekTimeUs = msec * 1000ll;
switch (mState) {
case UNINITIALIZED:
return INVALID_OPERATION;
case STOPPED:
{
mStartupSeekTimeUs = seekTimeUs;
break;
}
case PLAYING:
case PAUSED:
{
mAtEOS = false;
mPlayer->seekToAsync(seekTimeUs);
break;
}
default:
TRESPASS();
break;
}
return OK;
}
status_t NuPlayerDriver::getCurrentPosition(int *msec) {
Mutex::Autolock autoLock(mLock);
if (mPositionUs < 0) {
*msec = 0;
} else {
*msec = (mPositionUs + 500ll) / 1000;
}
return OK;
}
status_t NuPlayerDriver::getDuration(int *msec) {
Mutex::Autolock autoLock(mLock);
if (mDurationUs < 0) {
*msec = 0;
} else {
*msec = (mDurationUs + 500ll) / 1000;
}
return OK;
}
status_t NuPlayerDriver::reset() {
Mutex::Autolock autoLock(mLock);
mResetInProgress = true;
mPlayer->resetAsync();
while (mResetInProgress) {
mCondition.wait(mLock);
}
mDurationUs = -1;
mPositionUs = -1;
mState = UNINITIALIZED;
mStartupSeekTimeUs = -1;
return OK;
}
status_t NuPlayerDriver::setLooping(int loop) {
return INVALID_OPERATION;
}
player_type NuPlayerDriver::playerType() {
return NU_PLAYER;
}
status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
if (reply == NULL) {
ALOGE("reply is a NULL pointer");
return BAD_VALUE;
}
int32_t methodId;
status_t ret = request.readInt32(&methodId);
if (ret != OK) {
ALOGE("Failed to retrieve the requested method to invoke");
return ret;
}
switch (methodId) {
case INVOKE_ID_SET_VIDEO_SCALING_MODE:
{
int mode = request.readInt32();
return mPlayer->setVideoScalingMode(mode);
}
default:
{
return INVALID_OPERATION;
}
}
}
void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
mPlayer->setAudioSink(audioSink);
}
status_t NuPlayerDriver::setParameter(int key, const Parcel &request) {
return INVALID_OPERATION;
}
status_t NuPlayerDriver::getParameter(int key, Parcel *reply) {
return INVALID_OPERATION;
}
status_t NuPlayerDriver::getMetadata(
const media::Metadata::Filter& ids, Parcel *records) {
return INVALID_OPERATION;
}
void NuPlayerDriver::notifyResetComplete() {
Mutex::Autolock autoLock(mLock);
CHECK(mResetInProgress);
mResetInProgress = false;
mCondition.broadcast();
}
void NuPlayerDriver::notifyDuration(int64_t durationUs) {
Mutex::Autolock autoLock(mLock);
mDurationUs = durationUs;
}
void NuPlayerDriver::notifyPosition(int64_t positionUs) {
Mutex::Autolock autoLock(mLock);
mPositionUs = positionUs;
}
void NuPlayerDriver::notifySeekComplete() {
notifyListener(MEDIA_SEEK_COMPLETE);
}
void NuPlayerDriver::notifyFrameStats(
int64_t numFramesTotal, int64_t numFramesDropped) {
Mutex::Autolock autoLock(mLock);
mNumFramesTotal = numFramesTotal;
mNumFramesDropped = numFramesDropped;
}
status_t NuPlayerDriver::dump(int fd, const Vector<String16> &args) const {
Mutex::Autolock autoLock(mLock);
FILE *out = fdopen(dup(fd), "w");
fprintf(out, " NuPlayer\n");
fprintf(out, " numFramesTotal(%lld), numFramesDropped(%lld), "
"percentageDropped(%.2f)\n",
mNumFramesTotal,
mNumFramesDropped,
mNumFramesTotal == 0
? 0.0 : (double)mNumFramesDropped / mNumFramesTotal);
fclose(out);
out = NULL;
return OK;
}
void NuPlayerDriver::notifyListener(int msg, int ext1, int ext2) {
if (msg == MEDIA_PLAYBACK_COMPLETE || msg == MEDIA_ERROR) {
mAtEOS = true;
}
sendEvent(msg, ext1, ext2);
}
} // namespace android