/*
* Copyright 2017 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 "NuPlayer2Driver"
#include <inttypes.h>
#include <utils/Log.h>
#include <cutils/properties.h>
#include "NuPlayer2Driver.h"
#include "NuPlayer2.h"
#include "NuPlayer2Source.h"
#include <media/DataSourceDesc.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/ALooper.h>
#include <media/stagefright/foundation/AUtils.h>
#include <media/stagefright/foundation/ByteUtils.h>
#include <media/stagefright/MediaClock.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
#include <media/IMediaAnalyticsService.h>
static const int kDumpLockRetries = 50;
static const int kDumpLockSleepUs = 20000;
namespace android {
struct ParcelWrapper : public RefBase {
static sp<ParcelWrapper> Create(const Parcel *p) {
if (p != NULL) {
sp<ParcelWrapper> pw = new ParcelWrapper();
if (pw->appendFrom(p) == OK) {
return pw;
}
}
return NULL;
}
const Parcel *getParcel() {
return mParcel;
}
protected:
virtual ~ParcelWrapper() {
if (mParcel != NULL) {
delete mParcel;
}
}
private:
ParcelWrapper()
: mParcel(NULL) { }
status_t appendFrom(const Parcel *p) {
if (mParcel == NULL) {
mParcel = new Parcel;
}
return mParcel->appendFrom(p, 0 /* start */, p->dataSize());
}
Parcel *mParcel;
};
// key for media statistics
static const char *kKeyPlayer = "nuplayer";
// attrs for media statistics
// NB: these are matched with public Java API constants defined
// in frameworks/base/media/java/android/media/MediaPlayer2.java
// These must be kept synchronized with the constants there.
static const char *kPlayerVMime = "android.media.mediaplayer.video.mime";
static const char *kPlayerVCodec = "android.media.mediaplayer.video.codec";
static const char *kPlayerWidth = "android.media.mediaplayer.width";
static const char *kPlayerHeight = "android.media.mediaplayer.height";
static const char *kPlayerFrames = "android.media.mediaplayer.frames";
static const char *kPlayerFramesDropped = "android.media.mediaplayer.dropped";
static const char *kPlayerAMime = "android.media.mediaplayer.audio.mime";
static const char *kPlayerACodec = "android.media.mediaplayer.audio.codec";
static const char *kPlayerDuration = "android.media.mediaplayer.durationMs";
static const char *kPlayerPlaying = "android.media.mediaplayer.playingMs";
static const char *kPlayerError = "android.media.mediaplayer.err";
static const char *kPlayerErrorCode = "android.media.mediaplayer.errcode";
// NB: These are not yet exposed as public Java API constants.
static const char *kPlayerErrorState = "android.media.mediaplayer.errstate";
static const char *kPlayerDataSourceType = "android.media.mediaplayer.dataSource";
//
static const char *kPlayerRebuffering = "android.media.mediaplayer.rebufferingMs";
static const char *kPlayerRebufferingCount = "android.media.mediaplayer.rebuffers";
static const char *kPlayerRebufferingAtExit = "android.media.mediaplayer.rebufferExit";
NuPlayer2Driver::NuPlayer2Driver(pid_t pid, uid_t uid)
: mState(STATE_IDLE),
mAsyncResult(UNKNOWN_ERROR),
mSrcId(0),
mSetSurfaceInProgress(false),
mDurationUs(-1),
mPositionUs(-1),
mSeekInProgress(false),
mPlayingTimeUs(0),
mRebufferingTimeUs(0),
mRebufferingEvents(0),
mRebufferingAtExit(false),
mLooper(new ALooper),
mNuPlayer2Looper(new ALooper),
mMediaClock(new MediaClock),
mPlayer(new NuPlayer2(pid, uid, mMediaClock)),
mPlayerFlags(0),
mAnalyticsItem(NULL),
mClientUid(uid),
mAtEOS(false),
mLooping(false),
mAutoLoop(false) {
ALOGD("NuPlayer2Driver(%p) created, clientPid(%d)", this, pid);
mLooper->setName("NuPlayer2Driver Looper");
mNuPlayer2Looper->setName("NuPlayer2 Looper");
mMediaClock->init();
// set up an analytics record
mAnalyticsItem = new MediaAnalyticsItem(kKeyPlayer);
mAnalyticsItem->setUid(mClientUid);
mNuPlayer2Looper->start(
false, /* runOnCallingThread */
true, /* canCallJava */
PRIORITY_AUDIO);
mNuPlayer2Looper->registerHandler(mPlayer);
mPlayer->setDriver(this);
}
NuPlayer2Driver::~NuPlayer2Driver() {
ALOGV("~NuPlayer2Driver(%p)", this);
mNuPlayer2Looper->stop();
mLooper->stop();
// finalize any pending metrics, usually a no-op.
updateMetrics("destructor");
logMetrics("destructor");
if (mAnalyticsItem != NULL) {
delete mAnalyticsItem;
mAnalyticsItem = NULL;
}
}
status_t NuPlayer2Driver::initCheck() {
mLooper->start(
false, /* runOnCallingThread */
true, /* canCallJava */
PRIORITY_AUDIO);
mLooper->registerHandler(this);
return OK;
}
status_t NuPlayer2Driver::setDataSource(const sp<DataSourceDesc> &dsd) {
ALOGV("setDataSource(%p)", this);
Mutex::Autolock autoLock(mLock);
if (mState != STATE_IDLE) {
return INVALID_OPERATION;
}
mSrcId = dsd->mId;
mState = STATE_SET_DATASOURCE_PENDING;
mPlayer->setDataSourceAsync(dsd);
while (mState == STATE_SET_DATASOURCE_PENDING) {
mCondition.wait(mLock);
}
return mAsyncResult;
}
status_t NuPlayer2Driver::prepareNextDataSource(const sp<DataSourceDesc> &dsd) {
ALOGV("prepareNextDataSource(%p)", this);
Mutex::Autolock autoLock(mLock);
mPlayer->prepareNextDataSourceAsync(dsd);
return OK;
}
status_t NuPlayer2Driver::playNextDataSource(int64_t srcId) {
ALOGV("playNextDataSource(%p)", this);
Mutex::Autolock autoLock(mLock);
mSrcId = srcId;
mPlayer->playNextDataSource(srcId);
return OK;
}
status_t NuPlayer2Driver::setVideoSurfaceTexture(const sp<ANativeWindowWrapper> &nww) {
ALOGV("setVideoSurfaceTexture(%p)", this);
Mutex::Autolock autoLock(mLock);
if (mSetSurfaceInProgress) {
return INVALID_OPERATION;
}
switch (mState) {
case STATE_SET_DATASOURCE_PENDING:
case STATE_RESET_IN_PROGRESS:
return INVALID_OPERATION;
default:
break;
}
mSetSurfaceInProgress = true;
mPlayer->setVideoSurfaceTextureAsync(nww);
while (mSetSurfaceInProgress) {
mCondition.wait(mLock);
}
return OK;
}
status_t NuPlayer2Driver::getBufferingSettings(BufferingSettings* buffering) {
ALOGV("getBufferingSettings(%p)", this);
{
Mutex::Autolock autoLock(mLock);
if (mState == STATE_IDLE) {
return INVALID_OPERATION;
}
}
return mPlayer->getBufferingSettings(buffering);
}
status_t NuPlayer2Driver::setBufferingSettings(const BufferingSettings& buffering) {
ALOGV("setBufferingSettings(%p)", this);
{
Mutex::Autolock autoLock(mLock);
if (mState == STATE_IDLE) {
return INVALID_OPERATION;
}
}
return mPlayer->setBufferingSettings(buffering);
}
status_t NuPlayer2Driver::prepareAsync() {
ALOGV("prepareAsync(%p)", this);
Mutex::Autolock autoLock(mLock);
switch (mState) {
case STATE_UNPREPARED:
mState = STATE_PREPARING;
mPlayer->prepareAsync();
return OK;
case STATE_STOPPED:
// this is really just paused. handle as seek to start
mAtEOS = false;
mState = STATE_STOPPED_AND_PREPARING;
mPlayer->seekToAsync(0, MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC /* mode */,
true /* needNotify */);
return OK;
default:
return INVALID_OPERATION;
};
}
status_t NuPlayer2Driver::start() {
ALOGD("start(%p), state is %d, eos is %d", this, mState, mAtEOS);
Mutex::Autolock autoLock(mLock);
return start_l();
}
status_t NuPlayer2Driver::start_l() {
switch (mState) {
case STATE_PAUSED:
case STATE_STOPPED_AND_PREPARED:
case STATE_PREPARED:
{
mPlayer->start();
// fall through
}
case STATE_RUNNING:
{
if (mAtEOS) {
mPlayer->seekToAsync(0);
mAtEOS = false;
mPositionUs = -1;
}
break;
}
default:
return INVALID_OPERATION;
}
mState = STATE_RUNNING;
return OK;
}
status_t NuPlayer2Driver::stop() {
ALOGD("stop(%p)", this);
Mutex::Autolock autoLock(mLock);
switch (mState) {
case STATE_RUNNING:
mPlayer->pause();
// fall through
case STATE_PAUSED:
mState = STATE_STOPPED;
//notifyListener_l(MEDIA2_STOPPED);
break;
case STATE_PREPARED:
case STATE_STOPPED:
case STATE_STOPPED_AND_PREPARING:
case STATE_STOPPED_AND_PREPARED:
mState = STATE_STOPPED;
break;
default:
return INVALID_OPERATION;
}
return OK;
}
status_t NuPlayer2Driver::pause() {
ALOGD("pause(%p)", this);
// The NuPlayerRenderer may get flushed if pause for long enough, e.g. the pause timeout tear
// down for audio offload mode. If that happens, the NuPlayerRenderer will no longer know the
// current position. So similar to seekTo, update |mPositionUs| to the pause position by calling
// getCurrentPosition here.
int64_t unused;
getCurrentPosition(&unused);
Mutex::Autolock autoLock(mLock);
switch (mState) {
case STATE_PAUSED:
case STATE_PREPARED:
return OK;
case STATE_RUNNING:
mState = STATE_PAUSED;
mPlayer->pause();
break;
default:
return INVALID_OPERATION;
}
return OK;
}
bool NuPlayer2Driver::isPlaying() {
return mState == STATE_RUNNING && !mAtEOS;
}
status_t NuPlayer2Driver::setPlaybackSettings(const AudioPlaybackRate &rate) {
status_t err = mPlayer->setPlaybackSettings(rate);
if (err == OK) {
// try to update position
int64_t unused;
getCurrentPosition(&unused);
Mutex::Autolock autoLock(mLock);
if (rate.mSpeed == 0.f && mState == STATE_RUNNING) {
mState = STATE_PAUSED;
} else if (rate.mSpeed != 0.f
&& (mState == STATE_PAUSED
|| mState == STATE_STOPPED_AND_PREPARED
|| mState == STATE_PREPARED)) {
err = start_l();
}
}
return err;
}
status_t NuPlayer2Driver::getPlaybackSettings(AudioPlaybackRate *rate) {
return mPlayer->getPlaybackSettings(rate);
}
status_t NuPlayer2Driver::setSyncSettings(const AVSyncSettings &sync, float videoFpsHint) {
return mPlayer->setSyncSettings(sync, videoFpsHint);
}
status_t NuPlayer2Driver::getSyncSettings(AVSyncSettings *sync, float *videoFps) {
return mPlayer->getSyncSettings(sync, videoFps);
}
status_t NuPlayer2Driver::seekTo(int64_t msec, MediaPlayer2SeekMode mode) {
ALOGD("seekTo(%p) (%lld ms, %d) at state %d", this, (long long)msec, mode, mState);
Mutex::Autolock autoLock(mLock);
int64_t seekTimeUs = msec * 1000ll;
switch (mState) {
case STATE_PREPARED:
case STATE_STOPPED_AND_PREPARED:
case STATE_PAUSED:
case STATE_RUNNING:
{
mAtEOS = false;
mSeekInProgress = true;
mPlayer->seekToAsync(seekTimeUs, mode, true /* needNotify */);
break;
}
default:
return INVALID_OPERATION;
}
mPositionUs = seekTimeUs;
return OK;
}
status_t NuPlayer2Driver::getCurrentPosition(int64_t *msec) {
int64_t tempUs = 0;
{
Mutex::Autolock autoLock(mLock);
if (mSeekInProgress || (mState == STATE_PAUSED && !mAtEOS)) {
tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
*msec = divRound(tempUs, (int64_t)(1000));
return OK;
}
}
status_t ret = mPlayer->getCurrentPosition(&tempUs);
Mutex::Autolock autoLock(mLock);
// We need to check mSeekInProgress here because mPlayer->seekToAsync is an async call, which
// means getCurrentPosition can be called before seek is completed. Iow, renderer may return a
// position value that's different the seek to position.
if (ret != OK) {
tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
} else {
mPositionUs = tempUs;
}
*msec = divRound(tempUs, (int64_t)(1000));
return OK;
}
status_t NuPlayer2Driver::getDuration(int64_t *msec) {
Mutex::Autolock autoLock(mLock);
if (mDurationUs < 0) {
return UNKNOWN_ERROR;
}
*msec = (mDurationUs + 500ll) / 1000;
return OK;
}
void NuPlayer2Driver::updateMetrics(const char *where) {
if (where == NULL) {
where = "unknown";
}
ALOGV("updateMetrics(%p) from %s at state %d", this, where, mState);
// gather the final stats for this record
Vector<sp<AMessage>> trackStats;
mPlayer->getStats(&trackStats);
if (trackStats.size() > 0) {
for (size_t i = 0; i < trackStats.size(); ++i) {
const sp<AMessage> &stats = trackStats.itemAt(i);
AString mime;
stats->findString("mime", &mime);
AString name;
stats->findString("component-name", &name);
if (mime.startsWith("video/")) {
int32_t width, height;
mAnalyticsItem->setCString(kPlayerVMime, mime.c_str());
if (!name.empty()) {
mAnalyticsItem->setCString(kPlayerVCodec, name.c_str());
}
if (stats->findInt32("width", &width)
&& stats->findInt32("height", &height)) {
mAnalyticsItem->setInt32(kPlayerWidth, width);
mAnalyticsItem->setInt32(kPlayerHeight, height);
}
int64_t numFramesTotal = 0;
int64_t numFramesDropped = 0;
stats->findInt64("frames-total", &numFramesTotal);
stats->findInt64("frames-dropped-output", &numFramesDropped);
mAnalyticsItem->setInt64(kPlayerFrames, numFramesTotal);
mAnalyticsItem->setInt64(kPlayerFramesDropped, numFramesDropped);
} else if (mime.startsWith("audio/")) {
mAnalyticsItem->setCString(kPlayerAMime, mime.c_str());
if (!name.empty()) {
mAnalyticsItem->setCString(kPlayerACodec, name.c_str());
}
}
}
}
// always provide duration and playing time, even if they have 0/unknown values.
// getDuration() uses mLock for mutex -- careful where we use it.
int64_t duration_ms = -1;
getDuration(&duration_ms);
mAnalyticsItem->setInt64(kPlayerDuration, duration_ms);
mAnalyticsItem->setInt64(kPlayerPlaying, (mPlayingTimeUs+500)/1000 );
if (mRebufferingEvents != 0) {
mAnalyticsItem->setInt64(kPlayerRebuffering, (mRebufferingTimeUs+500)/1000 );
mAnalyticsItem->setInt32(kPlayerRebufferingCount, mRebufferingEvents);
mAnalyticsItem->setInt32(kPlayerRebufferingAtExit, mRebufferingAtExit);
}
mAnalyticsItem->setCString(kPlayerDataSourceType, mPlayer->getDataSourceType());
}
void NuPlayer2Driver::logMetrics(const char *where) {
if (where == NULL) {
where = "unknown";
}
ALOGV("logMetrics(%p) from %s at state %d", this, where, mState);
if (mAnalyticsItem == NULL || mAnalyticsItem->isEnabled() == false) {
return;
}
// log only non-empty records
// we always updateMetrics() before we get here
// and that always injects 3 fields (duration, playing time, and
// datasource) into the record.
// So the canonical "empty" record has 3 elements in it.
if (mAnalyticsItem->count() > 3) {
mAnalyticsItem->selfrecord();
// re-init in case we prepare() and start() again.
delete mAnalyticsItem ;
mAnalyticsItem = new MediaAnalyticsItem(kKeyPlayer);
if (mAnalyticsItem) {
mAnalyticsItem->setUid(mClientUid);
}
} else {
ALOGV("did not have anything to record");
}
}
status_t NuPlayer2Driver::reset() {
ALOGD("reset(%p) at state %d", this, mState);
updateMetrics("reset");
logMetrics("reset");
Mutex::Autolock autoLock(mLock);
switch (mState) {
case STATE_IDLE:
return OK;
case STATE_SET_DATASOURCE_PENDING:
case STATE_RESET_IN_PROGRESS:
return INVALID_OPERATION;
case STATE_PREPARING:
{
notifyListener_l(mSrcId, MEDIA2_PREPARED);
break;
}
default:
break;
}
if (mState != STATE_STOPPED) {
// notifyListener_l(MEDIA2_STOPPED);
}
mState = STATE_RESET_IN_PROGRESS;
mPlayer->resetAsync();
while (mState == STATE_RESET_IN_PROGRESS) {
mCondition.wait(mLock);
}
mDurationUs = -1;
mPositionUs = -1;
mLooping = false;
mPlayingTimeUs = 0;
mRebufferingTimeUs = 0;
mRebufferingEvents = 0;
mRebufferingAtExit = false;
return OK;
}
status_t NuPlayer2Driver::notifyAt(int64_t mediaTimeUs) {
ALOGV("notifyAt(%p), time:%lld", this, (long long)mediaTimeUs);
return mPlayer->notifyAt(mediaTimeUs);
}
status_t NuPlayer2Driver::setLooping(int loop) {
mLooping = loop != 0;
return OK;
}
status_t NuPlayer2Driver::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, err(%d)", ret);
return ret;
}
switch (methodId) {
case MEDIA_PLAYER2_INVOKE_ID_SET_VIDEO_SCALING_MODE:
{
int mode = request.readInt32();
return mPlayer->setVideoScalingMode(mode);
}
case MEDIA_PLAYER2_INVOKE_ID_GET_TRACK_INFO:
{
return mPlayer->getTrackInfo(reply);
}
case MEDIA_PLAYER2_INVOKE_ID_SELECT_TRACK:
{
int trackIndex = request.readInt32();
int64_t msec = 0;
// getCurrentPosition should always return OK
getCurrentPosition(&msec);
return mPlayer->selectTrack(trackIndex, true /* select */, msec * 1000ll);
}
case MEDIA_PLAYER2_INVOKE_ID_UNSELECT_TRACK:
{
int trackIndex = request.readInt32();
return mPlayer->selectTrack(trackIndex, false /* select */, 0xdeadbeef /* not used */);
}
case MEDIA_PLAYER2_INVOKE_ID_GET_SELECTED_TRACK:
{
int32_t type = request.readInt32();
return mPlayer->getSelectedTrack(type, reply);
}
default:
{
return INVALID_OPERATION;
}
}
}
void NuPlayer2Driver::setAudioSink(const sp<AudioSink> &audioSink) {
mPlayer->setAudioSink(audioSink);
mAudioSink = audioSink;
}
status_t NuPlayer2Driver::setParameter(
int /* key */, const Parcel & /* request */) {
return INVALID_OPERATION;
}
status_t NuPlayer2Driver::getParameter(int key, Parcel *reply) {
if (key == FOURCC('m','t','r','X')) {
// mtrX -- a play on 'metrics' (not matrix)
// gather current info all together, parcel it, and send it back
updateMetrics("api");
mAnalyticsItem->writeToParcel(reply);
return OK;
}
return INVALID_OPERATION;
}
status_t NuPlayer2Driver::getMetadata(
const media::Metadata::Filter& /* ids */, Parcel *records) {
Mutex::Autolock autoLock(mLock);
using media::Metadata;
Metadata meta(records);
meta.appendBool(
Metadata::kPauseAvailable,
mPlayerFlags & NuPlayer2::Source::FLAG_CAN_PAUSE);
meta.appendBool(
Metadata::kSeekBackwardAvailable,
mPlayerFlags & NuPlayer2::Source::FLAG_CAN_SEEK_BACKWARD);
meta.appendBool(
Metadata::kSeekForwardAvailable,
mPlayerFlags & NuPlayer2::Source::FLAG_CAN_SEEK_FORWARD);
meta.appendBool(
Metadata::kSeekAvailable,
mPlayerFlags & NuPlayer2::Source::FLAG_CAN_SEEK);
return OK;
}
void NuPlayer2Driver::notifyResetComplete(int64_t /* srcId */) {
ALOGD("notifyResetComplete(%p)", this);
Mutex::Autolock autoLock(mLock);
CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
mState = STATE_IDLE;
mCondition.broadcast();
}
void NuPlayer2Driver::notifySetSurfaceComplete(int64_t /* srcId */) {
ALOGV("notifySetSurfaceComplete(%p)", this);
Mutex::Autolock autoLock(mLock);
CHECK(mSetSurfaceInProgress);
mSetSurfaceInProgress = false;
mCondition.broadcast();
}
void NuPlayer2Driver::notifyDuration(int64_t /* srcId */, int64_t durationUs) {
Mutex::Autolock autoLock(mLock);
mDurationUs = durationUs;
}
void NuPlayer2Driver::notifyMorePlayingTimeUs(int64_t /* srcId */, int64_t playingUs) {
Mutex::Autolock autoLock(mLock);
mPlayingTimeUs += playingUs;
}
void NuPlayer2Driver::notifyMoreRebufferingTimeUs(int64_t /* srcId */, int64_t rebufferingUs) {
Mutex::Autolock autoLock(mLock);
mRebufferingTimeUs += rebufferingUs;
mRebufferingEvents++;
}
void NuPlayer2Driver::notifyRebufferingWhenExit(int64_t /* srcId */, bool status) {
Mutex::Autolock autoLock(mLock);
mRebufferingAtExit = status;
}
void NuPlayer2Driver::notifySeekComplete(int64_t srcId) {
ALOGV("notifySeekComplete(%p)", this);
Mutex::Autolock autoLock(mLock);
mSeekInProgress = false;
notifySeekComplete_l(srcId);
}
void NuPlayer2Driver::notifySeekComplete_l(int64_t srcId) {
bool wasSeeking = true;
if (mState == STATE_STOPPED_AND_PREPARING) {
wasSeeking = false;
mState = STATE_STOPPED_AND_PREPARED;
mCondition.broadcast();
} else if (mState == STATE_STOPPED) {
// no need to notify listener
return;
}
notifyListener_l(srcId, wasSeeking ? MEDIA2_SEEK_COMPLETE : MEDIA2_PREPARED);
}
status_t NuPlayer2Driver::dump(
int fd, const Vector<String16> & /* args */) const {
Vector<sp<AMessage> > trackStats;
mPlayer->getStats(&trackStats);
AString logString(" NuPlayer2\n");
char buf[256] = {0};
bool locked = false;
for (int i = 0; i < kDumpLockRetries; ++i) {
if (mLock.tryLock() == NO_ERROR) {
locked = true;
break;
}
usleep(kDumpLockSleepUs);
}
if (locked) {
snprintf(buf, sizeof(buf), " state(%d), atEOS(%d), looping(%d), autoLoop(%d)\n",
mState, mAtEOS, mLooping, mAutoLoop);
mLock.unlock();
} else {
snprintf(buf, sizeof(buf), " NPD(%p) lock is taken\n", this);
}
logString.append(buf);
for (size_t i = 0; i < trackStats.size(); ++i) {
const sp<AMessage> &stats = trackStats.itemAt(i);
AString mime;
if (stats->findString("mime", &mime)) {
snprintf(buf, sizeof(buf), " mime(%s)\n", mime.c_str());
logString.append(buf);
}
AString name;
if (stats->findString("component-name", &name)) {
snprintf(buf, sizeof(buf), " decoder(%s)\n", name.c_str());
logString.append(buf);
}
if (mime.startsWith("video/")) {
int32_t width, height;
if (stats->findInt32("width", &width)
&& stats->findInt32("height", &height)) {
snprintf(buf, sizeof(buf), " resolution(%d x %d)\n", width, height);
logString.append(buf);
}
int64_t numFramesTotal = 0;
int64_t numFramesDropped = 0;
stats->findInt64("frames-total", &numFramesTotal);
stats->findInt64("frames-dropped-output", &numFramesDropped);
snprintf(buf, sizeof(buf), " numFramesTotal(%lld), numFramesDropped(%lld), "
"percentageDropped(%.2f%%)\n",
(long long)numFramesTotal,
(long long)numFramesDropped,
numFramesTotal == 0
? 0.0 : (double)(numFramesDropped * 100) / numFramesTotal);
logString.append(buf);
}
}
ALOGI("%s", logString.c_str());
if (fd >= 0) {
FILE *out = fdopen(dup(fd), "w");
fprintf(out, "%s", logString.c_str());
fclose(out);
out = NULL;
}
return OK;
}
void NuPlayer2Driver::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatNotifyListener: {
int64_t srcId;
int32_t msgId;
int32_t ext1 = 0;
int32_t ext2 = 0;
CHECK(msg->findInt64("srcId", &srcId));
CHECK(msg->findInt32("messageId", &msgId));
msg->findInt32("ext1", &ext1);
msg->findInt32("ext2", &ext2);
sp<ParcelWrapper> in;
sp<RefBase> obj;
if (msg->findObject("parcel", &obj) && obj != NULL) {
in = static_cast<ParcelWrapper *>(obj.get());
}
sendEvent(srcId, msgId, ext1, ext2, (in == NULL ? NULL : in->getParcel()));
break;
}
default:
break;
}
}
void NuPlayer2Driver::notifyListener(
int64_t srcId, int msg, int ext1, int ext2, const Parcel *in) {
Mutex::Autolock autoLock(mLock);
notifyListener_l(srcId, msg, ext1, ext2, in);
}
void NuPlayer2Driver::notifyListener_l(
int64_t srcId, int msg, int ext1, int ext2, const Parcel *in) {
ALOGD("notifyListener_l(%p), (%lld, %d, %d, %d, %d), loop setting(%d, %d)",
this, (long long)srcId, msg, ext1, ext2,
(in == NULL ? -1 : (int)in->dataSize()), mAutoLoop, mLooping);
if (srcId == mSrcId) {
switch (msg) {
case MEDIA2_PLAYBACK_COMPLETE:
{
if (mState != STATE_RESET_IN_PROGRESS) {
if (mAutoLoop) {
audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
if (mAudioSink != NULL) {
streamType = mAudioSink->getAudioStreamType();
}
if (streamType == AUDIO_STREAM_NOTIFICATION) {
ALOGW("disabling auto-loop for notification");
mAutoLoop = false;
}
}
if (mLooping || mAutoLoop) {
mPlayer->seekToAsync(0);
if (mAudioSink != NULL) {
// The renderer has stopped the sink at the end in order to play out
// the last little bit of audio. In looping mode, we need to restart it.
mAudioSink->start();
}
// don't send completion event when looping
return;
}
if (property_get_bool("persist.debug.sf.stats", false)) {
Vector<String16> args;
dump(-1, args);
}
mPlayer->pause();
mState = STATE_PAUSED;
}
// fall through
}
case MEDIA2_ERROR:
{
// when we have an error, add it to the analytics for this playback.
// ext1 is our primary 'error type' value. Only add ext2 when non-zero.
// [test against msg is due to fall through from previous switch value]
if (msg == MEDIA2_ERROR) {
mAnalyticsItem->setInt32(kPlayerError, ext1);
if (ext2 != 0) {
mAnalyticsItem->setInt32(kPlayerErrorCode, ext2);
}
mAnalyticsItem->setCString(kPlayerErrorState, stateString(mState).c_str());
}
mAtEOS = true;
break;
}
default:
break;
}
}
sp<AMessage> notify = new AMessage(kWhatNotifyListener, this);
notify->setInt64("srcId", srcId);
notify->setInt32("messageId", msg);
notify->setInt32("ext1", ext1);
notify->setInt32("ext2", ext2);
notify->setObject("parcel", ParcelWrapper::Create(in));
notify->post();
}
void NuPlayer2Driver::notifySetDataSourceCompleted(int64_t /* srcId */, status_t err) {
Mutex::Autolock autoLock(mLock);
CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
mAsyncResult = err;
mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
mCondition.broadcast();
}
void NuPlayer2Driver::notifyPrepareCompleted(int64_t srcId, status_t err) {
ALOGV("notifyPrepareCompleted %d", err);
Mutex::Autolock autoLock(mLock);
if (srcId != mSrcId) {
if (err == OK) {
notifyListener_l(srcId, MEDIA2_PREPARED);
} else {
notifyListener_l(srcId, MEDIA2_ERROR, MEDIA2_ERROR_UNKNOWN, err);
}
return;
}
if (mState != STATE_PREPARING) {
// We were preparing asynchronously when the client called
// reset(), we sent a premature "prepared" notification and
// then initiated the reset. This notification is stale.
CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
return;
}
CHECK_EQ(mState, STATE_PREPARING);
mAsyncResult = err;
if (err == OK) {
// update state before notifying client, so that if client calls back into NuPlayer2Driver
// in response, NuPlayer2Driver has the right state
mState = STATE_PREPARED;
notifyListener_l(srcId, MEDIA2_PREPARED);
} else {
mState = STATE_UNPREPARED;
notifyListener_l(srcId, MEDIA2_ERROR, MEDIA2_ERROR_UNKNOWN, err);
}
sp<MetaData> meta = mPlayer->getFileMeta();
int32_t loop;
if (meta != NULL
&& meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) {
mAutoLoop = true;
}
mCondition.broadcast();
}
void NuPlayer2Driver::notifyFlagsChanged(int64_t /* srcId */, uint32_t flags) {
Mutex::Autolock autoLock(mLock);
mPlayerFlags = flags;
}
// Modular DRM
status_t NuPlayer2Driver::prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId)
{
ALOGV("prepareDrm(%p) state: %d", this, mState);
// leaving the state verification for mediaplayer.cpp
status_t ret = mPlayer->prepareDrm(uuid, drmSessionId);
ALOGV("prepareDrm ret: %d", ret);
return ret;
}
status_t NuPlayer2Driver::releaseDrm()
{
ALOGV("releaseDrm(%p) state: %d", this, mState);
// leaving the state verification for mediaplayer.cpp
status_t ret = mPlayer->releaseDrm();
ALOGV("releaseDrm ret: %d", ret);
return ret;
}
std::string NuPlayer2Driver::stateString(State state) {
const char *rval = NULL;
char rawbuffer[16]; // allows "%d"
switch (state) {
case STATE_IDLE: rval = "IDLE"; break;
case STATE_SET_DATASOURCE_PENDING: rval = "SET_DATASOURCE_PENDING"; break;
case STATE_UNPREPARED: rval = "UNPREPARED"; break;
case STATE_PREPARING: rval = "PREPARING"; break;
case STATE_PREPARED: rval = "PREPARED"; break;
case STATE_RUNNING: rval = "RUNNING"; break;
case STATE_PAUSED: rval = "PAUSED"; break;
case STATE_RESET_IN_PROGRESS: rval = "RESET_IN_PROGRESS"; break;
case STATE_STOPPED: rval = "STOPPED"; break;
case STATE_STOPPED_AND_PREPARING: rval = "STOPPED_AND_PREPARING"; break;
case STATE_STOPPED_AND_PREPARED: rval = "STOPPED_AND_PREPARED"; break;
default:
// yes, this buffer is shared and vulnerable to races
snprintf(rawbuffer, sizeof(rawbuffer), "%d", state);
rval = rawbuffer;
break;
}
return rval;
}
} // namespace android